Kolab Groupware OBS

guam.spec Changed

buildtarball.sh Changed

guam-0.9.11.tar.gz/.git Added

guam-0.9.11.tar.gz/.git/HEAD Added

guam-0.9.11.tar.gz/.git/branches Added

guam-0.9.11.tar.gz/.git/config Added

guam-0.9.11.tar.gz/.git/description Added

guam-0.9.11.tar.gz/.git/hooks Added

guam-0.9.11.tar.gz/.git/hooks/applypatch-msg.sample Added

guam-0.9.11.tar.gz/.git/hooks/commit-msg.sample Added

guam-0.9.11.tar.gz/.git/hooks/fsmonitor-watchman.sample Added

@@ -0,0 +1,173 @@
+#!/usr/bin/perl
+
+use strict;
+use warnings;
+use IPC::Open2;
+
+# An example hook script to integrate Watchman
+# (https://facebook.github.io/watchman/) with git to speed up detecting
+# new and modified files.
+#
+# The hook is passed a version (currently 2) and last update token
+# formatted as a string and outputs to stdout a new update token and
+# all files that have been modified since the update token. Paths must
+# be relative to the root of the working tree and separated by a single NUL.
+#
+# To enable this hook, rename this file to "query-watchman" and set
+# 'git config core.fsmonitor .git/hooks/query-watchman'
+#
+my ($version, $last_update_token) = @ARGV;
+
+# Uncomment for debugging
+# print STDERR "$0 $version $last_update_token\n";
+
+# Check the hook interface version
+if ($version ne 2) {
+	die "Unsupported query-fsmonitor hook version '$version'.\n" .
+	 "Falling back to scanning...\n";
+}
+
+my $git_work_tree = get_working_dir();
+
+my $retry = 1;
+
+my $json_pkg;
+eval {
+	require JSON::XS;
+	$json_pkg = "JSON::XS";
+	1;
+} or do {
+	require JSON::PP;
+	$json_pkg = "JSON::PP";
+};
+
+launch_watchman();
+
+sub launch_watchman {
+	my $o = watchman_query();
+	if (is_work_tree_watched($o)) {
+		output_result($o->{clock}, @{$o->{files}});
+	}
+}
+
+sub output_result {
+	my ($clockid, @files) = @_;
+
+	# Uncomment for debugging watchman output
+	# open (my $fh, ">", ".git/watchman-output.out");
+	# binmode $fh, ":utf8";
+	# print $fh "$clockid\n@files\n";
+	# close $fh;
+
+	binmode STDOUT, ":utf8";
+	print $clockid;
+	print "\0";
+	local $, = "\0";
+	print @files;
+}
+
+sub watchman_clock {
+	my $response = qx/watchman clock "$git_work_tree"/;
+	die "Failed to get clock id on '$git_work_tree'.\n" .
+		"Falling back to scanning...\n" if $? != 0;
+
+	return $json_pkg->new->utf8->decode($response);
+}
+
+sub watchman_query {
+	my $pid = open2(\*CHLD_OUT, \*CHLD_IN, 'watchman -j --no-pretty')
+	or die "open2() failed: $!\n" .
+	"Falling back to scanning...\n";
+
+	# In the query expression below we're asking for names of files that
+	# changed since $last_update_token but not from the .git folder.
+	#
+	# To accomplish this, we're using the "since" generator to use the
+	# recency index to select candidate nodes and "fields" to limit the
+	# output to file names only. Then we're using the "expression" term to
+	# further constrain the results.
+	if (substr($last_update_token, 0, 1) eq "c") {
+		$last_update_token = "\"$last_update_token\"";
+	}
+	my $query = <<"	END";
+		["query", "$git_work_tree", {
+			"since": $last_update_token,
+			"fields": ["name"],
+			"expression": ["not", ["dirname", ".git"]]
+		}]
+	END
+
+	# Uncomment for debugging the watchman query
+	# open (my $fh, ">", ".git/watchman-query.json");
+	# print $fh $query;
+	# close $fh;
+
+	print CHLD_IN $query;
+	close CHLD_IN;
+	my $response = do {local $/; <CHLD_OUT>};
+
+	# Uncomment for debugging the watch response
+	# open ($fh, ">", ".git/watchman-response.json");
+	# print $fh $response;
+	# close $fh;
+
+	die "Watchman: command returned no output.\n" .
+	"Falling back to scanning...\n" if $response eq "";
+	die "Watchman: command returned invalid output: $response\n" .
+	"Falling back to scanning...\n" unless $response =~ /^\{/;
+
+	return $json_pkg->new->utf8->decode($response);
+}
+
+sub is_work_tree_watched {
+	my ($output) = @_;
+	my $error = $output->{error};
+	if ($retry > 0 and $error and $error =~ m/unable to resolve root .* directory (.*) is not watched/) {
+		$retry--;
+		my $response = qx/watchman watch "$git_work_tree"/;
+		die "Failed to make watchman watch '$git_work_tree'.\n" .
+		 "Falling back to scanning...\n" if $? != 0;
+		$output = $json_pkg->new->utf8->decode($response);
+		$error = $output->{error};
+		die "Watchman: $error.\n" .
+		"Falling back to scanning...\n" if $error;
+
+		# Uncomment for debugging watchman output
+		# open (my $fh, ">", ".git/watchman-output.out");
+		# close $fh;
+
+		# Watchman will always return all files on the first query so
+		# return the fast "everything is dirty" flag to git and do the
+		# Watchman query just to get it over with now so we won't pay
+		# the cost in git to look up each individual file.
+		my $o = watchman_clock();
+		$error = $output->{error};
+
+		die "Watchman: $error.\n" .
+		"Falling back to scanning...\n" if $error;
+
+		output_result($o->{clock}, ("/"));
+		$last_update_token = $o->{clock};
+
+		eval { launch_watchman() };
+		return 0;
+	}
+
+	die "Watchman: $error.\n" .
+	"Falling back to scanning...\n" if $error;
+
+	return 1;
+}
+
+sub get_working_dir {
+	my $working_dir;
+	if ($^O =~ 'msys' || $^O =~ 'cygwin') {
+		$working_dir = Win32::GetCwd();
+		$working_dir =~ tr/\\/\//;
+	} else {
+		require Cwd;
+		$working_dir = Cwd::cwd();
+	}
+
+	return $working_dir;
+}

guam-0.9.11.tar.gz/.git/hooks/post-update.sample Added

guam-0.9.11.tar.gz/.git/hooks/pre-applypatch.sample Added

guam-0.9.11.tar.gz/.git/hooks/pre-commit.sample Added

@@ -0,0 +1,49 @@
+#!/usr/bin/sh
+#
+# An example 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.
+#
+# To enable this hook, rename this file to "pre-commit".
+
+if git rev-parse --verify HEAD >/dev/null 2>&1
+then
+	against=HEAD
+else
+	# Initial commit: diff against an empty tree object
+	against=$(git hash-object -t tree /dev/null)
+fi
+
+# If you want to allow non-ASCII filenames set this variable to true.
+allownonascii=$(git config --type=bool hooks.allownonascii)
+
+# Redirect output to stderr.
+exec 1>&2
+
+# Cross platform projects tend to avoid non-ASCII filenames; prevent
+# them from being added to the repository. We exploit the fact that the
+# printable range starts at the space character and ends with tilde.
+if [ "$allownonascii" != "true" ] &&
+	# 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.
+	test $(git diff --cached --name-only --diff-filter=A -z $against |
+	 LC_ALL=C tr -d '[ -~]\0' | wc -c) != 0
+then
+	cat <<\EOF
+Error: Attempt to add a non-ASCII file name.
+
+This can cause problems if you want to work with people on other platforms.
+
+To be portable it is advisable to rename the file.
+
+If you know what you are doing you can disable this check using:
+
+ git config hooks.allownonascii true
+EOF
+	exit 1
+fi
+
+# If there are whitespace errors, print the offending file names and fail.
+exec git diff-index --check --cached $against --

guam-0.9.11.tar.gz/.git/hooks/pre-merge-commit.sample Added

guam-0.9.11.tar.gz/.git/hooks/pre-push.sample Added

@@ -0,0 +1,53 @@
+#!/usr/bin/sh
+
+# An example hook script to verify what is about to be pushed. Called by "git
+# push" after it has checked the remote status, but before anything has been
+# pushed. If this script exits with a non-zero status nothing will be pushed.
+#
+# This hook is called with the following parameters:
+#
+# $1 -- Name of the remote to which the push is being done
+# $2 -- URL to which the push is being done
+#
+# If pushing without using a named remote those arguments will be equal.
+#
+# Information about the commits which are being pushed is supplied as lines to
+# the standard input in the form:
+#
+# <local ref> <local oid> <remote ref> <remote oid>
+#
+# This sample shows how to prevent push of commits where the log message starts
+# with "WIP" (work in progress).
+
+remote="$1"
+url="$2"
+
+zero=$(git hash-object --stdin </dev/null | tr '[0-9a-f]' '0')
+
+while read local_ref local_oid remote_ref remote_oid
+do
+	if test "$local_oid" = "$zero"
+	then
+		# Handle delete
+		:
+	else
+		if test "$remote_oid" = "$zero"
+		then
+			# New branch, examine all commits
+			range="$local_oid"
+		else
+			# Update to existing branch, examine new commits
+			range="$remote_oid..$local_oid"
+		fi
+
+		# Check for WIP commit
+		commit=$(git rev-list -n 1 --grep '^WIP' "$range")
+		if test -n "$commit"
+		then
+			echo >&2 "Found WIP commit in $local_ref, not pushing"
+			exit 1
+		fi
+	fi
+done
+
+exit 0

guam-0.9.11.tar.gz/.git/hooks/pre-rebase.sample Added

@@ -0,0 +1,169 @@
+#!/usr/bin/sh
+#
+# Copyright (c) 2006, 2008 Junio C Hamano
+#
+# The "pre-rebase" hook is run just before "git rebase" starts doing
+# its job, and can prevent the command from running by exiting with
+# non-zero status.
+#
+# The hook is called with the following parameters:
+#
+# $1 -- the upstream the series was forked from.
+# $2 -- the branch being rebased (or empty when rebasing the current branch).
+#
+# This sample shows how to prevent topic branches that are already
+# merged to 'next' branch from getting rebased, because allowing it
+# would result in rebasing already published history.
+
+publish=next
+basebranch="$1"
+if test "$#" = 2
+then
+	topic="refs/heads/$2"
+else
+	topic=`git symbolic-ref HEAD` ||
+	exit 0 ;# we do not interrupt rebasing detached HEAD
+fi
+
+case "$topic" in
+refs/heads/??/*)
+	;;
+*)
+	exit 0 ;# we do not interrupt others.
+	;;
+esac
+
+# Now we are dealing with a topic branch being rebased
+# on top of master. Is it OK to rebase it?
+
+# Does the topic really exist?
+git show-ref -q "$topic" || {
+	echo >&2 "No such branch $topic"
+	exit 1
+}
+
+# Is topic fully merged to master?
+not_in_master=`git rev-list --pretty=oneline ^master "$topic"`
+if test -z "$not_in_master"
+then
+	echo >&2 "$topic is fully merged to master; better remove it."
+	exit 1 ;# we could allow it, but there is no point.
+fi
+
+# Is topic ever merged to next? If so you should not be rebasing it.
+only_next_1=`git rev-list ^master "^$topic" ${publish} | sort`
+only_next_2=`git rev-list ^master ${publish} | sort`
+if test "$only_next_1" = "$only_next_2"
+then
+	not_in_topic=`git rev-list "^$topic" master`
+	if test -z "$not_in_topic"
+	then
+		echo >&2 "$topic is already up to date with master"
+		exit 1 ;# we could allow it, but there is no point.
+	else
+		exit 0
+	fi
+else
+	not_in_next=`git rev-list --pretty=oneline ^${publish} "$topic"`
+	/usr/bin/perl -e '
+		my $topic = $ARGV[0];
+		my $msg = "* $topic has commits already merged to public branch:\n";
+		my (%not_in_next) = map {
+			/^([0-9a-f]+) /;
+			($1 => 1);
+		} split(/\n/, $ARGV[1]);
+		for my $elem (map {
+				/^([0-9a-f]+) (.*)$/;
+				[$1 => $2];
+			} split(/\n/, $ARGV[2])) {
+			if (!exists $not_in_next{$elem->[0]}) {
+				if ($msg) {
+					print STDERR $msg;
+					undef $msg;
+				}
+				print STDERR " $elem->[1]\n";
+			}
+		}
+	' "$topic" "$not_in_next" "$not_in_master"
+	exit 1
+fi
+
+<<\DOC_END
+
+This sample hook safeguards topic branches that have been
+published from being rewound.
+
+The workflow assumed here is:
+
+ * Once a topic branch forks from "master", "master" is never
+ merged into it again (either directly or indirectly).
+
+ * Once a topic branch is fully cooked and merged into "master",
+ it is deleted. If you need to build on top of it to correct
+ earlier mistakes, a new topic branch is created by forking at
+ the tip of the "master". This is not strictly necessary, but
+ it makes it easier to keep your history simple.
+
+ * Whenever you need to test or publish your changes to topic
+ branches, merge them into "next" branch.
+
+The script, being an example, hardcodes the publish branch name
+to be "next", but it is trivial to make it configurable via
+$GIT_DIR/config mechanism.
+
+With this workflow, you would want to know:
+
+(1) ... if a topic branch has ever been merged to "next". Young
+ topic branches can have stupid mistakes you would rather
+ clean up before publishing, and things that have not been
+ merged into other branches can be easily rebased without
+ affecting other people. But once it is published, you would
+ not want to rewind it.
+
+(2) ... if a topic branch has been fully merged to "master".
+ Then you can delete it. More importantly, you should not
+ build on top of it -- other people may already want to
+ change things related to the topic as patches against your
+ "master", so if you need further changes, it is better to
+ fork the topic (perhaps with the same name) afresh from the
+ tip of "master".
+
+Let's look at this example:
+
+		 o---o---o---o---o---o---o---o---o---o "next"
+		 / / / /
+		 / a---a---b A / /
+		/ / / /
+	 / / c---c---c---c B /
+	 / / / \ /
+	 / / / b---b C \ /
+	 / / / / \ /
+ ---o---o---o---o---o---o---o---o---o---o---o "master"
+
+
+A, B and C are topic branches.
+
+ * A has one fix since it was merged up to "next".
+
+ * B has finished. It has been fully merged up to "master" and "next",
+ and is ready to be deleted.
+
+ * C has not merged to "next" at all.
+
+We would want to allow C to be rebased, refuse A, and encourage
+B to be deleted.
+
+To compute (1):
+
+	git rev-list ^master ^topic next
+	git rev-list ^master next
+
+	if these match, topic has not merged in next at all.
+
+To compute (2):
+
+	git rev-list master..topic
+
+	if this is empty, it is fully merged to "master".
+
+DOC_END

guam-0.9.11.tar.gz/.git/hooks/pre-receive.sample Added

guam-0.9.11.tar.gz/.git/hooks/prepare-commit-msg.sample Added

@@ -0,0 +1,42 @@
+#!/usr/bin/sh
+#
+# An example hook script to prepare the commit log message.
+# Called by "git commit" with the name of the file that has the
+# commit message, followed by the description of the commit
+# message's source.  The hook's purpose is to edit the commit
+# message file.  If the hook fails with a non-zero status,
+# the commit is aborted.
+#
+# To enable this hook, rename this file to "prepare-commit-msg".
+
+# This hook includes three examples. The first one removes the
+# "# Please enter the commit message..." help message.
+#
+# The second includes the output of "git diff --name-status -r"
+# into the message, just before the "git status" output.  It is
+# commented because it doesn't cope with --amend or with squashed
+# commits.
+#
+# The third example adds a Signed-off-by line to the message, that can
+# still be edited.  This is rarely a good idea.
+
+COMMIT_MSG_FILE=$1
+COMMIT_SOURCE=$2
+SHA1=$3
+
+/usr/bin/perl -i.bak -ne 'print unless(m/^. Please enter the commit message/..m/^#$/)' "$COMMIT_MSG_FILE"
+
+# case "$COMMIT_SOURCE,$SHA1" in
+#  ,|template,)
+#    /usr/bin/perl -i.bak -pe '
+#       print "\n" . `git diff --cached --name-status -r`
+# 	 if /^#/ && $first++ == 0' "$COMMIT_MSG_FILE" ;;
+#  *) ;;
+# esac
+
+# SOB=$(git var GIT_COMMITTER_IDENT | sed -n 's/^$.*>$.*$/Signed-off-by: \1/p')
+# git interpret-trailers --in-place --trailer "$SOB" "$COMMIT_MSG_FILE"
+# if test -z "$COMMIT_SOURCE"
+# then
+#   /usr/bin/perl -i.bak -pe 'print "\n" if !$first_line++' "$COMMIT_MSG_FILE"
+# fi

guam-0.9.11.tar.gz/.git/hooks/push-to-checkout.sample Added

@@ -0,0 +1,78 @@
+#!/usr/bin/sh
+
+# An example hook script to update a checked-out tree on a git push.
+#
+# This hook is invoked by git-receive-pack(1) when it reacts to git
+# push and updates reference(s) in its repository, and when the push
+# tries to update the branch that is currently checked out and the
+# receive.denyCurrentBranch configuration variable is set to
+# updateInstead.
+#
+# By default, such a push is refused if the working tree and the index
+# of the remote repository has any difference from the currently
+# checked out commit; when both the working tree and the index match
+# the current commit, they are updated to match the newly pushed tip
+# of the branch. This hook is to be used to override the default
+# behaviour; however the code below reimplements the default behaviour
+# as a starting point for convenient modification.
+#
+# The hook receives the commit with which the tip of the current
+# branch is going to be updated:
+commit=$1
+
+# It can exit with a non-zero status to refuse the push (when it does
+# so, it must not modify the index or the working tree).
+die () {
+	echo >&2 "$*"
+	exit 1
+}
+
+# Or it can make any necessary changes to the working tree and to the
+# index to bring them to the desired state when the tip of the current
+# branch is updated to the new commit, and exit with a zero status.
+#
+# For example, the hook can simply run git read-tree -u -m HEAD "$1"
+# in order to emulate git fetch that is run in the reverse direction
+# with git push, as the two-tree form of git read-tree -u -m is
+# essentially the same as git switch or git checkout that switches
+# branches while keeping the local changes in the working tree that do
+# not interfere with the difference between the branches.
+
+# The below is a more-or-less exact translation to shell of the C code
+# for the default behaviour for git's push-to-checkout hook defined in
+# the push_to_deploy() function in builtin/receive-pack.c.
+#
+# Note that the hook will be executed from the repository directory,
+# not from the working tree, so if you want to perform operations on
+# the working tree, you will have to adapt your code accordingly, e.g.
+# by adding "cd .." or using relative paths.
+
+if ! git update-index -q --ignore-submodules --refresh
+then
+	die "Up-to-date check failed"
+fi
+
+if ! git diff-files --quiet --ignore-submodules --
+then
+	die "Working directory has unstaged changes"
+fi
+
+# This is a rough translation of:
+#
+# head_has_history() ? "HEAD" : EMPTY_TREE_SHA1_HEX
+if git cat-file -e HEAD 2>/dev/null
+then
+	head=HEAD
+else
+	head=$(git hash-object -t tree --stdin </dev/null)
+fi
+
+if ! git diff-index --quiet --cached --ignore-submodules $head --
+then
+	die "Working directory has staged changes"
+fi
+
+if ! git read-tree -u -m "$commit"
+then
+	die "Could not update working tree to new HEAD"
+fi

guam-0.9.11.tar.gz/.git/hooks/update.sample Added

@@ -0,0 +1,128 @@
+#!/usr/bin/sh
+#
+# An example hook script to block unannotated tags from entering.
+# Called by "git receive-pack" with arguments: refname sha1-old sha1-new
+#
+# To enable this hook, rename this file to "update".
+#
+# Config
+# ------
+# hooks.allowunannotated
+# This boolean sets whether unannotated tags will be allowed into the
+# repository. By default they won't be.
+# hooks.allowdeletetag
+# This boolean sets whether deleting tags will be allowed in the
+# repository. By default they won't be.
+# hooks.allowmodifytag
+# This boolean sets whether a tag may be modified after creation. By default
+# it won't be.
+# hooks.allowdeletebranch
+# This boolean sets whether deleting branches will be allowed in the
+# repository. By default they won't be.
+# hooks.denycreatebranch
+# This boolean sets whether remotely creating branches will be denied
+# in the repository. By default this is allowed.
+#
+
+# --- Command line
+refname="$1"
+oldrev="$2"
+newrev="$3"
+
+# --- Safety check
+if [ -z "$GIT_DIR" ]; then
+	echo "Don't run this script from the command line." >&2
+	echo " (if you want, you could supply GIT_DIR then run" >&2
+	echo " $0 <ref> <oldrev> <newrev>)" >&2
+	exit 1
+fi
+
+if [ -z "$refname" -o -z "$oldrev" -o -z "$newrev" ]; then
+	echo "usage: $0 <ref> <oldrev> <newrev>" >&2
+	exit 1
+fi
+
+# --- Config
+allowunannotated=$(git config --type=bool hooks.allowunannotated)
+allowdeletebranch=$(git config --type=bool hooks.allowdeletebranch)
+denycreatebranch=$(git config --type=bool hooks.denycreatebranch)
+allowdeletetag=$(git config --type=bool hooks.allowdeletetag)
+allowmodifytag=$(git config --type=bool hooks.allowmodifytag)
+
+# check for no description
+projectdesc=$(sed -e '1q' "$GIT_DIR/description")
+case "$projectdesc" in
+"Unnamed repository"* | "")
+	echo "*** Project description file hasn't been set" >&2
+	exit 1
+	;;
+esac
+
+# --- Check types
+# if $newrev is 0000...0000, it's a commit to delete a ref.
+zero=$(git hash-object --stdin </dev/null | tr '[0-9a-f]' '0')
+if [ "$newrev" = "$zero" ]; then
+	newrev_type=delete
+else
+	newrev_type=$(git cat-file -t $newrev)
+fi
+
+case "$refname","$newrev_type" in
+	refs/tags/*,commit)
+		# un-annotated tag
+		short_refname=${refname##refs/tags/}
+		if [ "$allowunannotated" != "true" ]; then
+			echo "*** The un-annotated tag, $short_refname, is not allowed in this repository" >&2
+			echo "*** Use 'git tag [ -a | -s ]' for tags you want to propagate." >&2
+			exit 1
+		fi
+		;;
+	refs/tags/*,delete)
+		# delete tag
+		if [ "$allowdeletetag" != "true" ]; then
+			echo "*** Deleting a tag is not allowed in this repository" >&2
+			exit 1
+		fi
+		;;
+	refs/tags/*,tag)
+		# annotated tag
+		if [ "$allowmodifytag" != "true" ] && git rev-parse $refname > /dev/null 2>&1
+		then
+			echo "*** Tag '$refname' already exists." >&2
+			echo "*** Modifying a tag is not allowed in this repository." >&2
+			exit 1
+		fi
+		;;
+	refs/heads/*,commit)
+		# branch
+		if [ "$oldrev" = "$zero" -a "$denycreatebranch" = "true" ]; then
+			echo "*** Creating a branch is not allowed in this repository" >&2
+			exit 1
+		fi
+		;;
+	refs/heads/*,delete)
+		# delete branch
+		if [ "$allowdeletebranch" != "true" ]; then
+			echo "*** Deleting a branch is not allowed in this repository" >&2
+			exit 1
+		fi
+		;;
+	refs/remotes/*,commit)
+		# tracking branch
+		;;
+	refs/remotes/*,delete)
+		# delete tracking branch
+		if [ "$allowdeletebranch" != "true" ]; then
+			echo "*** Deleting a tracking branch is not allowed in this repository" >&2
+			exit 1
+		fi
+		;;
+	*)
+		# Anything else (is there anything else?)
+		echo "*** Update hook: unknown type of update to ref $refname of type $newrev_type" >&2
+		exit 1
+		;;
+esac
+
+# --- Finished
+exit 0

guam-0.9.11.tar.gz/.git/index Added

guam-0.9.11.tar.gz/.git/info Added

guam-0.9.11.tar.gz/.git/info/exclude Added

guam-0.9.11.tar.gz/.git/logs Added

guam-0.9.11.tar.gz/.git/logs/HEAD Added

guam-0.9.11.tar.gz/.git/logs/refs Added

guam-0.9.11.tar.gz/.git/logs/refs/heads Added

guam-0.9.11.tar.gz/.git/logs/refs/heads/master Added

guam-0.9.11.tar.gz/.git/logs/refs/remotes Added

guam-0.9.11.tar.gz/.git/logs/refs/remotes/origin Added

guam-0.9.11.tar.gz/.git/logs/refs/remotes/origin/HEAD Added

guam-0.9.11.tar.gz/.git/objects Added

guam-0.9.11.tar.gz/.git/objects/info Added

guam-0.9.11.tar.gz/.git/objects/pack Added

guam-0.9.11.tar.gz/.git/objects/pack/pack-db1d81032292d962a49c2bc6d40531b6bd626605.idx Added

guam-0.9.11.tar.gz/.git/objects/pack/pack-db1d81032292d962a49c2bc6d40531b6bd626605.pack Added

guam-0.9.11.tar.gz/.git/packed-refs Added

@@ -0,0 +1,56 @@
+# pack-refs with: peeled fully-peeled sorted 
+0d3fd56445f1377797b9bc11391c0e0079c8ffed refs/remotes/origin/dev/mollekopf
+7aaf330bba6bf5a3c10eaaff46fd73d79f17d054 refs/remotes/origin/dev/mollekopf2
+8dd174db900da9c8c11ce9b8b407829203211a26 refs/remotes/origin/dev/simplifyfolderextraction
+a9d12d9852d9db96c90a59eccb4a3e6ef9400bde refs/remotes/origin/develop
+deb3292b33aee3578791bd8646704d8117874fb1 refs/remotes/origin/feature/0.9-with-rebar2
+68385bd51d75daad051a596fa2d5ebb941e1b501 refs/remotes/origin/feature/T932_literal_continuations
+4e85df4e2ecf6c8001a47f1504a2acd1d084c099 refs/remotes/origin/feature/autodetect_ipv6
+98c3f09fbb8ecb6f532516c60993476fca591905 refs/remotes/origin/feature/implicit_tls_delayed_ssl_start
+5c9b2751009f71f7c313b3ad2c28213ef1a4e063 refs/remotes/origin/feature/init_script
+cd57385625e419c681bc31293fefb30d65d8465f refs/remotes/origin/feature/prep_for_0.9
+fcddaf18a88fbcd50becabdf93bafb224e395b87 refs/remotes/origin/feature/support_tag_arrives_before_command
+35d90722caccd894ad6b896e531da0c4baf1e38a refs/remotes/origin/guam-0.7
+967bacc60233c9859872b94904ae22e6fa29afb2 refs/remotes/origin/hotfix/no_tls_server_response_fixup
+a9d12d9852d9db96c90a59eccb4a3e6ef9400bde refs/remotes/origin/master
+f87a3d4bd7f4b3785158b4a89607514de93ede76 refs/tags/0.8
+^1341f21c1c73b1ba4c01a0ef8675d86ac6355d6d
+e3a417235274ee544303c7907a47fc5ef9de566d refs/tags/0.8.1
+89e2d7a1121a4dafc2c24b91fef51e6d13e6a636 refs/tags/0.8.2
+455c217013276cbd2255a21e67a8c75d359bfd6d refs/tags/0.8.3
+aafa371262207eca88ef28c0638d5bd1608d5a6c refs/tags/0.9.0
+^ca8594566b5c945a3488110f6a1eac3880826bf4
+2fbe6c77b27e222246bb1880167ee59890e781e4 refs/tags/0.9.10
+^0f65089ab05a0533baaab653bfa09f45b7f077b3
+068ad51cc0c0b73fd0344f9c0d3501e474d909c5 refs/tags/0.9.11
+^8332e06ac83a37ec92ce56aec30d48b966ed8c45
+e5699da6b7b804fd2c37c68567a5e81445f08b96 refs/tags/0.9.6
+^0005a4d8aaca9db0d961cdf6c5db6ac28f8c220c
+838c5dede048c8f15fcda35a6655660220ae9511 refs/tags/0.9.7
+^d854029b1d1b256eef63f95bd68bf25710e475f1
+e643a0506a5e7c554c3acd46d43edb050a81f040 refs/tags/0.9.8
+^1b203d8d6cabd14afea8fedfecf4cb6908610879
+5efd7863c40a3899ffa59b437a9ef93c03ed01c9 refs/tags/0.9.9
+^c728094f548b9f79575b39ff470d8ed04e19ea99
+9f162081a5b155c28806aa4cc7bace4f2680515a refs/tags/guam-0.1
+^6f4d215405da8230d5f49e3b660b8a4d3cc91c01
+4c3cbaddc86bd33c64b6992c0784cb48ec5f6c55 refs/tags/guam-0.2
+^792126ff585db722d517269f3b71f6e12aefde94
+1c4e771c32032143906f218f84c9aa919fb1415c refs/tags/guam-0.3
+^a5a07a9d4140b595db83406983da3ffb4b69ef46
+0d15f30e1cb2c3c33a139679a54b98988d1bc6a9 refs/tags/guam-0.4
+^b5b0c1b4b1732727b636409cf80425fae0b9023f
+efb8b7e8816d4f2e634d493cd71ea77546f92bbd refs/tags/guam-0.5
+^5df52529128b811400682c0c54546816af51c8e6
+0cdd67cd25befa558355834e42f4820b886f19bb refs/tags/guam-0.6
+^1ee333cb8de3bc642c3311e4ff82ff9cb966448f
+77129203985e6ce3daf6b3839b4460f161c3374d refs/tags/guam-0.7.0
+^ff40cefa1053d0f79ebd669aad199b87ff91abe5
+ab4e342436ce2f8c2c556a9cf17592b65b7c93c0 refs/tags/guam-0.7.1
+^6062291a36ae0348ee20207a4cc8c19aefcd674a
+7e0cab2c2af732ef717bc8abc213966909cedb45 refs/tags/guam-0.7.2
+^a7b7976618d5020e15e71e990e5570fe26127e23
+56edb7296780d424f0268a97a9b600511284bb1c refs/tags/guam-0.7.3
+^35d90722caccd894ad6b896e531da0c4baf1e38a
+7290f8a12e1d9b6dcdb1b70cd846fd4b11b3bf6a refs/tags/guam-0.9.5
+^3d1fc7327a47ea9466816bb9389db332a21b8aaf

guam-0.9.11.tar.gz/.git/refs Added

guam-0.9.11.tar.gz/.git/refs/heads Added

guam-0.9.11.tar.gz/.git/refs/heads/master Added

guam-0.9.11.tar.gz/.git/refs/remotes Added

guam-0.9.11.tar.gz/.git/refs/remotes/origin Added

guam-0.9.11.tar.gz/.git/refs/remotes/origin/HEAD Added

guam-0.9.11.tar.gz/.git/refs/tags Added

guam-0.9.11.tar.gz/Makefile Changed

guam-0.9.11.tar.gz/_build/default/lib/eimap/.git Added

guam-0.9.11.tar.gz/_build/default/lib/eimap/.git/HEAD Added

guam-0.9.11.tar.gz/_build/default/lib/eimap/.git/branches Added

guam-0.9.11.tar.gz/_build/default/lib/eimap/.git/config Added

guam-0.9.11.tar.gz/_build/default/lib/eimap/.git/description Added

guam-0.9.11.tar.gz/_build/default/lib/eimap/.git/hooks Added

guam-0.9.11.tar.gz/_build/default/lib/eimap/.git/hooks/applypatch-msg.sample Added

guam-0.9.11.tar.gz/_build/default/lib/eimap/.git/hooks/commit-msg.sample Added

guam-0.9.11.tar.gz/_build/default/lib/eimap/.git/hooks/fsmonitor-watchman.sample Added

@@ -0,0 +1,173 @@
+#!/usr/bin/perl
+
+use strict;
+use warnings;
+use IPC::Open2;
+
+# An example hook script to integrate Watchman
+# (https://facebook.github.io/watchman/) with git to speed up detecting
+# new and modified files.
+#
+# The hook is passed a version (currently 2) and last update token
+# formatted as a string and outputs to stdout a new update token and
+# all files that have been modified since the update token. Paths must
+# be relative to the root of the working tree and separated by a single NUL.
+#
+# To enable this hook, rename this file to "query-watchman" and set
+# 'git config core.fsmonitor .git/hooks/query-watchman'
+#
+my ($version, $last_update_token) = @ARGV;
+
+# Uncomment for debugging
+# print STDERR "$0 $version $last_update_token\n";
+
+# Check the hook interface version
+if ($version ne 2) {
+	die "Unsupported query-fsmonitor hook version '$version'.\n" .
+	 "Falling back to scanning...\n";
+}
+
+my $git_work_tree = get_working_dir();
+
+my $retry = 1;
+
+my $json_pkg;
+eval {
+	require JSON::XS;
+	$json_pkg = "JSON::XS";
+	1;
+} or do {
+	require JSON::PP;
+	$json_pkg = "JSON::PP";
+};
+
+launch_watchman();
+
+sub launch_watchman {
+	my $o = watchman_query();
+	if (is_work_tree_watched($o)) {
+		output_result($o->{clock}, @{$o->{files}});
+	}
+}
+
+sub output_result {
+	my ($clockid, @files) = @_;
+
+	# Uncomment for debugging watchman output
+	# open (my $fh, ">", ".git/watchman-output.out");
+	# binmode $fh, ":utf8";
+	# print $fh "$clockid\n@files\n";
+	# close $fh;
+
+	binmode STDOUT, ":utf8";
+	print $clockid;
+	print "\0";
+	local $, = "\0";
+	print @files;
+}
+
+sub watchman_clock {
+	my $response = qx/watchman clock "$git_work_tree"/;
+	die "Failed to get clock id on '$git_work_tree'.\n" .
+		"Falling back to scanning...\n" if $? != 0;
+
+	return $json_pkg->new->utf8->decode($response);
+}
+
+sub watchman_query {
+	my $pid = open2(\*CHLD_OUT, \*CHLD_IN, 'watchman -j --no-pretty')
+	or die "open2() failed: $!\n" .
+	"Falling back to scanning...\n";
+
+	# In the query expression below we're asking for names of files that
+	# changed since $last_update_token but not from the .git folder.
+	#
+	# To accomplish this, we're using the "since" generator to use the
+	# recency index to select candidate nodes and "fields" to limit the
+	# output to file names only. Then we're using the "expression" term to
+	# further constrain the results.
+	if (substr($last_update_token, 0, 1) eq "c") {
+		$last_update_token = "\"$last_update_token\"";
+	}
+	my $query = <<"	END";
+		["query", "$git_work_tree", {
+			"since": $last_update_token,
+			"fields": ["name"],
+			"expression": ["not", ["dirname", ".git"]]
+		}]
+	END
+
+	# Uncomment for debugging the watchman query
+	# open (my $fh, ">", ".git/watchman-query.json");
+	# print $fh $query;
+	# close $fh;
+
+	print CHLD_IN $query;
+	close CHLD_IN;
+	my $response = do {local $/; <CHLD_OUT>};
+
+	# Uncomment for debugging the watch response
+	# open ($fh, ">", ".git/watchman-response.json");
+	# print $fh $response;
+	# close $fh;
+
+	die "Watchman: command returned no output.\n" .
+	"Falling back to scanning...\n" if $response eq "";
+	die "Watchman: command returned invalid output: $response\n" .
+	"Falling back to scanning...\n" unless $response =~ /^\{/;
+
+	return $json_pkg->new->utf8->decode($response);
+}
+
+sub is_work_tree_watched {
+	my ($output) = @_;
+	my $error = $output->{error};
+	if ($retry > 0 and $error and $error =~ m/unable to resolve root .* directory (.*) is not watched/) {
+		$retry--;
+		my $response = qx/watchman watch "$git_work_tree"/;
+		die "Failed to make watchman watch '$git_work_tree'.\n" .
+		 "Falling back to scanning...\n" if $? != 0;
+		$output = $json_pkg->new->utf8->decode($response);
+		$error = $output->{error};
+		die "Watchman: $error.\n" .
+		"Falling back to scanning...\n" if $error;
+
+		# Uncomment for debugging watchman output
+		# open (my $fh, ">", ".git/watchman-output.out");
+		# close $fh;
+
+		# Watchman will always return all files on the first query so
+		# return the fast "everything is dirty" flag to git and do the
+		# Watchman query just to get it over with now so we won't pay
+		# the cost in git to look up each individual file.
+		my $o = watchman_clock();
+		$error = $output->{error};
+
+		die "Watchman: $error.\n" .
+		"Falling back to scanning...\n" if $error;
+
+		output_result($o->{clock}, ("/"));
+		$last_update_token = $o->{clock};
+
+		eval { launch_watchman() };
+		return 0;
+	}
+
+	die "Watchman: $error.\n" .
+	"Falling back to scanning...\n" if $error;
+
+	return 1;
+}
+
+sub get_working_dir {
+	my $working_dir;
+	if ($^O =~ 'msys' || $^O =~ 'cygwin') {
+		$working_dir = Win32::GetCwd();
+		$working_dir =~ tr/\\/\//;
+	} else {
+		require Cwd;
+		$working_dir = Cwd::cwd();
+	}
+
+	return $working_dir;
+}

guam-0.9.11.tar.gz/_build/default/lib/eimap/.git/hooks/post-update.sample Added

guam-0.9.11.tar.gz/_build/default/lib/eimap/.git/hooks/pre-applypatch.sample Added

guam-0.9.11.tar.gz/_build/default/lib/eimap/.git/hooks/pre-commit.sample Added

@@ -0,0 +1,49 @@
+#!/usr/bin/sh
+#
+# An example 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.
+#
+# To enable this hook, rename this file to "pre-commit".
+
+if git rev-parse --verify HEAD >/dev/null 2>&1
+then
+	against=HEAD
+else
+	# Initial commit: diff against an empty tree object
+	against=$(git hash-object -t tree /dev/null)
+fi
+
+# If you want to allow non-ASCII filenames set this variable to true.
+allownonascii=$(git config --type=bool hooks.allownonascii)
+
+# Redirect output to stderr.
+exec 1>&2
+
+# Cross platform projects tend to avoid non-ASCII filenames; prevent
+# them from being added to the repository. We exploit the fact that the
+# printable range starts at the space character and ends with tilde.
+if [ "$allownonascii" != "true" ] &&
+	# 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.
+	test $(git diff --cached --name-only --diff-filter=A -z $against |
+	 LC_ALL=C tr -d '[ -~]\0' | wc -c) != 0
+then
+	cat <<\EOF
+Error: Attempt to add a non-ASCII file name.
+
+This can cause problems if you want to work with people on other platforms.
+
+To be portable it is advisable to rename the file.
+
+If you know what you are doing you can disable this check using:
+
+ git config hooks.allownonascii true
+EOF
+	exit 1
+fi
+
+# If there are whitespace errors, print the offending file names and fail.
+exec git diff-index --check --cached $against --

guam-0.9.11.tar.gz/_build/default/lib/eimap/.git/hooks/pre-merge-commit.sample Added

guam-0.9.11.tar.gz/_build/default/lib/eimap/.git/hooks/pre-push.sample Added

@@ -0,0 +1,53 @@
+#!/usr/bin/sh
+
+# An example hook script to verify what is about to be pushed. Called by "git
+# push" after it has checked the remote status, but before anything has been
+# pushed. If this script exits with a non-zero status nothing will be pushed.
+#
+# This hook is called with the following parameters:
+#
+# $1 -- Name of the remote to which the push is being done
+# $2 -- URL to which the push is being done
+#
+# If pushing without using a named remote those arguments will be equal.
+#
+# Information about the commits which are being pushed is supplied as lines to
+# the standard input in the form:
+#
+# <local ref> <local oid> <remote ref> <remote oid>
+#
+# This sample shows how to prevent push of commits where the log message starts
+# with "WIP" (work in progress).
+
+remote="$1"
+url="$2"
+
+zero=$(git hash-object --stdin </dev/null | tr '[0-9a-f]' '0')
+
+while read local_ref local_oid remote_ref remote_oid
+do
+	if test "$local_oid" = "$zero"
+	then
+		# Handle delete
+		:
+	else
+		if test "$remote_oid" = "$zero"
+		then
+			# New branch, examine all commits
+			range="$local_oid"
+		else
+			# Update to existing branch, examine new commits
+			range="$remote_oid..$local_oid"
+		fi
+
+		# Check for WIP commit
+		commit=$(git rev-list -n 1 --grep '^WIP' "$range")
+		if test -n "$commit"
+		then
+			echo >&2 "Found WIP commit in $local_ref, not pushing"
+			exit 1
+		fi
+	fi
+done
+
+exit 0

guam-0.9.11.tar.gz/_build/default/lib/eimap/.git/hooks/pre-rebase.sample Added

@@ -0,0 +1,169 @@
+#!/usr/bin/sh
+#
+# Copyright (c) 2006, 2008 Junio C Hamano
+#
+# The "pre-rebase" hook is run just before "git rebase" starts doing
+# its job, and can prevent the command from running by exiting with
+# non-zero status.
+#
+# The hook is called with the following parameters:
+#
+# $1 -- the upstream the series was forked from.
+# $2 -- the branch being rebased (or empty when rebasing the current branch).
+#
+# This sample shows how to prevent topic branches that are already
+# merged to 'next' branch from getting rebased, because allowing it
+# would result in rebasing already published history.
+
+publish=next
+basebranch="$1"
+if test "$#" = 2
+then
+	topic="refs/heads/$2"
+else
+	topic=`git symbolic-ref HEAD` ||
+	exit 0 ;# we do not interrupt rebasing detached HEAD
+fi
+
+case "$topic" in
+refs/heads/??/*)
+	;;
+*)
+	exit 0 ;# we do not interrupt others.
+	;;
+esac
+
+# Now we are dealing with a topic branch being rebased
+# on top of master. Is it OK to rebase it?
+
+# Does the topic really exist?
+git show-ref -q "$topic" || {
+	echo >&2 "No such branch $topic"
+	exit 1
+}
+
+# Is topic fully merged to master?
+not_in_master=`git rev-list --pretty=oneline ^master "$topic"`
+if test -z "$not_in_master"
+then
+	echo >&2 "$topic is fully merged to master; better remove it."
+	exit 1 ;# we could allow it, but there is no point.
+fi
+
+# Is topic ever merged to next? If so you should not be rebasing it.
+only_next_1=`git rev-list ^master "^$topic" ${publish} | sort`
+only_next_2=`git rev-list ^master ${publish} | sort`
+if test "$only_next_1" = "$only_next_2"
+then
+	not_in_topic=`git rev-list "^$topic" master`
+	if test -z "$not_in_topic"
+	then
+		echo >&2 "$topic is already up to date with master"
+		exit 1 ;# we could allow it, but there is no point.
+	else
+		exit 0
+	fi
+else
+	not_in_next=`git rev-list --pretty=oneline ^${publish} "$topic"`
+	/usr/bin/perl -e '
+		my $topic = $ARGV[0];
+		my $msg = "* $topic has commits already merged to public branch:\n";
+		my (%not_in_next) = map {
+			/^([0-9a-f]+) /;
+			($1 => 1);
+		} split(/\n/, $ARGV[1]);
+		for my $elem (map {
+				/^([0-9a-f]+) (.*)$/;
+				[$1 => $2];
+			} split(/\n/, $ARGV[2])) {
+			if (!exists $not_in_next{$elem->[0]}) {
+				if ($msg) {
+					print STDERR $msg;
+					undef $msg;
+				}
+				print STDERR " $elem->[1]\n";
+			}
+		}
+	' "$topic" "$not_in_next" "$not_in_master"
+	exit 1
+fi
+
+<<\DOC_END
+
+This sample hook safeguards topic branches that have been
+published from being rewound.
+
+The workflow assumed here is:
+
+ * Once a topic branch forks from "master", "master" is never
+ merged into it again (either directly or indirectly).
+
+ * Once a topic branch is fully cooked and merged into "master",
+ it is deleted. If you need to build on top of it to correct
+ earlier mistakes, a new topic branch is created by forking at
+ the tip of the "master". This is not strictly necessary, but
+ it makes it easier to keep your history simple.
+
+ * Whenever you need to test or publish your changes to topic
+ branches, merge them into "next" branch.
+
+The script, being an example, hardcodes the publish branch name
+to be "next", but it is trivial to make it configurable via
+$GIT_DIR/config mechanism.
+
+With this workflow, you would want to know:
+
+(1) ... if a topic branch has ever been merged to "next". Young
+ topic branches can have stupid mistakes you would rather
+ clean up before publishing, and things that have not been
+ merged into other branches can be easily rebased without
+ affecting other people. But once it is published, you would
+ not want to rewind it.
+
+(2) ... if a topic branch has been fully merged to "master".
+ Then you can delete it. More importantly, you should not
+ build on top of it -- other people may already want to
+ change things related to the topic as patches against your
+ "master", so if you need further changes, it is better to
+ fork the topic (perhaps with the same name) afresh from the
+ tip of "master".
+
+Let's look at this example:
+
+		 o---o---o---o---o---o---o---o---o---o "next"
+		 / / / /
+		 / a---a---b A / /
+		/ / / /
+	 / / c---c---c---c B /
+	 / / / \ /
+	 / / / b---b C \ /
+	 / / / / \ /
+ ---o---o---o---o---o---o---o---o---o---o---o "master"
+
+
+A, B and C are topic branches.
+
+ * A has one fix since it was merged up to "next".
+
+ * B has finished. It has been fully merged up to "master" and "next",
+ and is ready to be deleted.
+
+ * C has not merged to "next" at all.
+
+We would want to allow C to be rebased, refuse A, and encourage
+B to be deleted.
+
+To compute (1):
+
+	git rev-list ^master ^topic next
+	git rev-list ^master next
+
+	if these match, topic has not merged in next at all.
+
+To compute (2):
+
+	git rev-list master..topic
+
+	if this is empty, it is fully merged to "master".
+
+DOC_END

guam-0.9.11.tar.gz/_build/default/lib/eimap/.git/hooks/pre-receive.sample Added

guam-0.9.11.tar.gz/_build/default/lib/eimap/.git/hooks/prepare-commit-msg.sample Added

@@ -0,0 +1,42 @@
+#!/usr/bin/sh
+#
+# An example hook script to prepare the commit log message.
+# Called by "git commit" with the name of the file that has the
+# commit message, followed by the description of the commit
+# message's source.  The hook's purpose is to edit the commit
+# message file.  If the hook fails with a non-zero status,
+# the commit is aborted.
+#
+# To enable this hook, rename this file to "prepare-commit-msg".
+
+# This hook includes three examples. The first one removes the
+# "# Please enter the commit message..." help message.
+#
+# The second includes the output of "git diff --name-status -r"
+# into the message, just before the "git status" output.  It is
+# commented because it doesn't cope with --amend or with squashed
+# commits.
+#
+# The third example adds a Signed-off-by line to the message, that can
+# still be edited.  This is rarely a good idea.
+
+COMMIT_MSG_FILE=$1
+COMMIT_SOURCE=$2
+SHA1=$3
+
+/usr/bin/perl -i.bak -ne 'print unless(m/^. Please enter the commit message/..m/^#$/)' "$COMMIT_MSG_FILE"
+
+# case "$COMMIT_SOURCE,$SHA1" in
+#  ,|template,)
+#    /usr/bin/perl -i.bak -pe '
+#       print "\n" . `git diff --cached --name-status -r`
+# 	 if /^#/ && $first++ == 0' "$COMMIT_MSG_FILE" ;;
+#  *) ;;
+# esac
+
+# SOB=$(git var GIT_COMMITTER_IDENT | sed -n 's/^$.*>$.*$/Signed-off-by: \1/p')
+# git interpret-trailers --in-place --trailer "$SOB" "$COMMIT_MSG_FILE"
+# if test -z "$COMMIT_SOURCE"
+# then
+#   /usr/bin/perl -i.bak -pe 'print "\n" if !$first_line++' "$COMMIT_MSG_FILE"
+# fi

guam-0.9.11.tar.gz/_build/default/lib/eimap/.git/hooks/push-to-checkout.sample Added

@@ -0,0 +1,78 @@
+#!/usr/bin/sh
+
+# An example hook script to update a checked-out tree on a git push.
+#
+# This hook is invoked by git-receive-pack(1) when it reacts to git
+# push and updates reference(s) in its repository, and when the push
+# tries to update the branch that is currently checked out and the
+# receive.denyCurrentBranch configuration variable is set to
+# updateInstead.
+#
+# By default, such a push is refused if the working tree and the index
+# of the remote repository has any difference from the currently
+# checked out commit; when both the working tree and the index match
+# the current commit, they are updated to match the newly pushed tip
+# of the branch. This hook is to be used to override the default
+# behaviour; however the code below reimplements the default behaviour
+# as a starting point for convenient modification.
+#
+# The hook receives the commit with which the tip of the current
+# branch is going to be updated:
+commit=$1
+
+# It can exit with a non-zero status to refuse the push (when it does
+# so, it must not modify the index or the working tree).
+die () {
+	echo >&2 "$*"
+	exit 1
+}
+
+# Or it can make any necessary changes to the working tree and to the
+# index to bring them to the desired state when the tip of the current
+# branch is updated to the new commit, and exit with a zero status.
+#
+# For example, the hook can simply run git read-tree -u -m HEAD "$1"
+# in order to emulate git fetch that is run in the reverse direction
+# with git push, as the two-tree form of git read-tree -u -m is
+# essentially the same as git switch or git checkout that switches
+# branches while keeping the local changes in the working tree that do
+# not interfere with the difference between the branches.
+
+# The below is a more-or-less exact translation to shell of the C code
+# for the default behaviour for git's push-to-checkout hook defined in
+# the push_to_deploy() function in builtin/receive-pack.c.
+#
+# Note that the hook will be executed from the repository directory,
+# not from the working tree, so if you want to perform operations on
+# the working tree, you will have to adapt your code accordingly, e.g.
+# by adding "cd .." or using relative paths.
+
+if ! git update-index -q --ignore-submodules --refresh
+then
+	die "Up-to-date check failed"
+fi
+
+if ! git diff-files --quiet --ignore-submodules --
+then
+	die "Working directory has unstaged changes"
+fi
+
+# This is a rough translation of:
+#
+# head_has_history() ? "HEAD" : EMPTY_TREE_SHA1_HEX
+if git cat-file -e HEAD 2>/dev/null
+then
+	head=HEAD
+else
+	head=$(git hash-object -t tree --stdin </dev/null)
+fi
+
+if ! git diff-index --quiet --cached --ignore-submodules $head --
+then
+	die "Working directory has staged changes"
+fi
+
+if ! git read-tree -u -m "$commit"
+then
+	die "Could not update working tree to new HEAD"
+fi

guam-0.9.11.tar.gz/_build/default/lib/eimap/.git/hooks/update.sample Added

@@ -0,0 +1,128 @@
+#!/usr/bin/sh
+#
+# An example hook script to block unannotated tags from entering.
+# Called by "git receive-pack" with arguments: refname sha1-old sha1-new
+#
+# To enable this hook, rename this file to "update".
+#
+# Config
+# ------
+# hooks.allowunannotated
+# This boolean sets whether unannotated tags will be allowed into the
+# repository. By default they won't be.
+# hooks.allowdeletetag
+# This boolean sets whether deleting tags will be allowed in the
+# repository. By default they won't be.
+# hooks.allowmodifytag
+# This boolean sets whether a tag may be modified after creation. By default
+# it won't be.
+# hooks.allowdeletebranch
+# This boolean sets whether deleting branches will be allowed in the
+# repository. By default they won't be.
+# hooks.denycreatebranch
+# This boolean sets whether remotely creating branches will be denied
+# in the repository. By default this is allowed.
+#
+
+# --- Command line
+refname="$1"
+oldrev="$2"
+newrev="$3"
+
+# --- Safety check
+if [ -z "$GIT_DIR" ]; then
+	echo "Don't run this script from the command line." >&2
+	echo " (if you want, you could supply GIT_DIR then run" >&2
+	echo " $0 <ref> <oldrev> <newrev>)" >&2
+	exit 1
+fi
+
+if [ -z "$refname" -o -z "$oldrev" -o -z "$newrev" ]; then
+	echo "usage: $0 <ref> <oldrev> <newrev>" >&2
+	exit 1
+fi
+
+# --- Config
+allowunannotated=$(git config --type=bool hooks.allowunannotated)
+allowdeletebranch=$(git config --type=bool hooks.allowdeletebranch)
+denycreatebranch=$(git config --type=bool hooks.denycreatebranch)
+allowdeletetag=$(git config --type=bool hooks.allowdeletetag)
+allowmodifytag=$(git config --type=bool hooks.allowmodifytag)
+
+# check for no description
+projectdesc=$(sed -e '1q' "$GIT_DIR/description")
+case "$projectdesc" in
+"Unnamed repository"* | "")
+	echo "*** Project description file hasn't been set" >&2
+	exit 1
+	;;
+esac
+
+# --- Check types
+# if $newrev is 0000...0000, it's a commit to delete a ref.
+zero=$(git hash-object --stdin </dev/null | tr '[0-9a-f]' '0')
+if [ "$newrev" = "$zero" ]; then
+	newrev_type=delete
+else
+	newrev_type=$(git cat-file -t $newrev)
+fi
+
+case "$refname","$newrev_type" in
+	refs/tags/*,commit)
+		# un-annotated tag
+		short_refname=${refname##refs/tags/}
+		if [ "$allowunannotated" != "true" ]; then
+			echo "*** The un-annotated tag, $short_refname, is not allowed in this repository" >&2
+			echo "*** Use 'git tag [ -a | -s ]' for tags you want to propagate." >&2
+			exit 1
+		fi
+		;;
+	refs/tags/*,delete)
+		# delete tag
+		if [ "$allowdeletetag" != "true" ]; then
+			echo "*** Deleting a tag is not allowed in this repository" >&2
+			exit 1
+		fi
+		;;
+	refs/tags/*,tag)
+		# annotated tag
+		if [ "$allowmodifytag" != "true" ] && git rev-parse $refname > /dev/null 2>&1
+		then
+			echo "*** Tag '$refname' already exists." >&2
+			echo "*** Modifying a tag is not allowed in this repository." >&2
+			exit 1
+		fi
+		;;
+	refs/heads/*,commit)
+		# branch
+		if [ "$oldrev" = "$zero" -a "$denycreatebranch" = "true" ]; then
+			echo "*** Creating a branch is not allowed in this repository" >&2
+			exit 1
+		fi
+		;;
+	refs/heads/*,delete)
+		# delete branch
+		if [ "$allowdeletebranch" != "true" ]; then
+			echo "*** Deleting a branch is not allowed in this repository" >&2
+			exit 1
+		fi
+		;;
+	refs/remotes/*,commit)
+		# tracking branch
+		;;
+	refs/remotes/*,delete)
+		# delete tracking branch
+		if [ "$allowdeletebranch" != "true" ]; then
+			echo "*** Deleting a tracking branch is not allowed in this repository" >&2
+			exit 1
+		fi
+		;;
+	*)
+		# Anything else (is there anything else?)
+		echo "*** Update hook: unknown type of update to ref $refname of type $newrev_type" >&2
+		exit 1
+		;;
+esac
+
+# --- Finished
+exit 0

guam-0.9.11.tar.gz/_build/default/lib/eimap/.git/index Added

guam-0.9.11.tar.gz/_build/default/lib/eimap/.git/info Added

guam-0.9.11.tar.gz/_build/default/lib/eimap/.git/info/exclude Added

guam-0.9.11.tar.gz/_build/default/lib/eimap/.git/logs Added

guam-0.9.11.tar.gz/_build/default/lib/eimap/.git/logs/HEAD Added

guam-0.9.11.tar.gz/_build/default/lib/eimap/.git/objects Added

guam-0.9.11.tar.gz/_build/default/lib/eimap/.git/objects/info Added

guam-0.9.11.tar.gz/_build/default/lib/eimap/.git/objects/pack Added

guam-0.9.11.tar.gz/_build/default/lib/eimap/.git/objects/pack/pack-c1b573ef1424aa74bc2580b50c5712c5af8505e9.idx Added

guam-0.9.11.tar.gz/_build/default/lib/eimap/.git/objects/pack/pack-c1b573ef1424aa74bc2580b50c5712c5af8505e9.pack Added

guam-0.9.11.tar.gz/_build/default/lib/eimap/.git/packed-refs Added

guam-0.9.11.tar.gz/_build/default/lib/eimap/.git/refs Added

guam-0.9.11.tar.gz/_build/default/lib/eimap/.git/refs/heads Added

guam-0.9.11.tar.gz/_build/default/lib/eimap/.git/refs/tags Added

guam-0.9.11.tar.gz/_build/default/lib/eimap/.git/refs/tags/0.1 Added

guam-0.9.11.tar.gz/_build/default/lib/eimap/.git/refs/tags/0.1.1 Added

guam-0.9.11.tar.gz/_build/default/lib/eimap/.git/refs/tags/0.1.2 Added

guam-0.9.11.tar.gz/_build/default/lib/eimap/.git/refs/tags/0.1.4 Added

guam-0.9.11.tar.gz/_build/default/lib/eimap/.git/refs/tags/0.2 Added

guam-0.9.11.tar.gz/_build/default/lib/eimap/.git/refs/tags/0.2.1 Added

guam-0.9.11.tar.gz/_build/default/lib/eimap/.git/refs/tags/0.2.2 Added

guam-0.9.11.tar.gz/_build/default/lib/eimap/.git/refs/tags/0.2.3 Added

guam-0.9.11.tar.gz/_build/default/lib/eimap/.git/refs/tags/0.2.4 Added

guam-0.9.11.tar.gz/_build/default/lib/eimap/.git/refs/tags/0.2.5 Added

guam-0.9.11.tar.gz/_build/default/lib/eimap/.git/refs/tags/0.3.0 Added

guam-0.9.11.tar.gz/_build/default/lib/eimap/.git/refs/tags/0.4.0 Added

guam-0.9.11.tar.gz/_build/default/lib/eimap/.git/refs/tags/0.4.1 Added

guam-0.9.11.tar.gz/_build/default/lib/eimap/.git/refs/tags/0.4.2 Added

guam-0.9.11.tar.gz/_build/default/lib/eimap/.git/refs/tags/0.4.3 Added

guam-0.9.11.tar.gz/_build/default/lib/eimap/.git/refs/tags/eimap-0.1.2 Added

guam-0.9.11.tar.gz/_build/default/lib/eimap/.git/refs/tags/eimap-0.1.5 Added

guam-0.9.11.tar.gz/_build/default/lib/eimap/.rebar3 Deleted

guam-0.9.11.tar.gz/_build/default/lib/eimap/.rebar3/rebar_compiler_erl Deleted

guam-0.9.11.tar.gz/_build/default/lib/eimap/.rebar3/rebar_compiler_erl/source.dag Deleted

guam-0.9.11.tar.gz/_build/default/lib/eimap/ebin Deleted

guam-0.9.11.tar.gz/_build/default/lib/eimap/ebin/eimap.app Deleted

guam-0.9.11.tar.gz/_build/default/lib/eimap/ebin/eimap.beam Deleted

guam-0.9.11.tar.gz/_build/default/lib/eimap/ebin/eimap_command.beam Deleted

guam-0.9.11.tar.gz/_build/default/lib/eimap/ebin/eimap_command_annotation.beam Deleted

guam-0.9.11.tar.gz/_build/default/lib/eimap/ebin/eimap_command_capability.beam Deleted

guam-0.9.11.tar.gz/_build/default/lib/eimap/ebin/eimap_command_compress.beam Deleted

guam-0.9.11.tar.gz/_build/default/lib/eimap/ebin/eimap_command_getmetadata.beam Deleted

guam-0.9.11.tar.gz/_build/default/lib/eimap/ebin/eimap_command_login.beam Deleted

guam-0.9.11.tar.gz/_build/default/lib/eimap/ebin/eimap_command_logout.beam Deleted

guam-0.9.11.tar.gz/_build/default/lib/eimap/ebin/eimap_command_namespace.beam Deleted

guam-0.9.11.tar.gz/_build/default/lib/eimap/ebin/eimap_command_noop.beam Deleted

guam-0.9.11.tar.gz/_build/default/lib/eimap/ebin/eimap_command_peek_message.beam Deleted

guam-0.9.11.tar.gz/_build/default/lib/eimap/ebin/eimap_command_starttls.beam Deleted

guam-0.9.11.tar.gz/_build/default/lib/eimap/ebin/eimap_command_status.beam Deleted

guam-0.9.11.tar.gz/_build/default/lib/eimap/ebin/eimap_command_switch_folder.beam Deleted

guam-0.9.11.tar.gz/_build/default/lib/eimap/ebin/eimap_uidset.beam Deleted

guam-0.9.11.tar.gz/_build/default/lib/eimap/ebin/eimap_utils.beam Deleted

guam-0.9.11.tar.gz/_build/default/lib/goldrush/.rebar3 Deleted

guam-0.9.11.tar.gz/_build/default/lib/goldrush/.rebar3/rebar_compiler_erl Deleted

guam-0.9.11.tar.gz/_build/default/lib/goldrush/.rebar3/rebar_compiler_erl/source.dag Deleted

guam-0.9.11.tar.gz/_build/default/lib/goldrush/ebin Deleted

guam-0.9.11.tar.gz/_build/default/lib/goldrush/ebin/glc.beam Deleted

guam-0.9.11.tar.gz/_build/default/lib/goldrush/ebin/glc_code.beam Deleted

guam-0.9.11.tar.gz/_build/default/lib/goldrush/ebin/glc_lib.beam Deleted

guam-0.9.11.tar.gz/_build/default/lib/goldrush/ebin/glc_ops.beam Deleted

guam-0.9.11.tar.gz/_build/default/lib/goldrush/ebin/glc_run.beam Deleted

guam-0.9.11.tar.gz/_build/default/lib/goldrush/ebin/goldrush.app Deleted

guam-0.9.11.tar.gz/_build/default/lib/goldrush/ebin/gr_app.beam Deleted

guam-0.9.11.tar.gz/_build/default/lib/goldrush/ebin/gr_context.beam Deleted

guam-0.9.11.tar.gz/_build/default/lib/goldrush/ebin/gr_counter.beam Deleted

guam-0.9.11.tar.gz/_build/default/lib/goldrush/ebin/gr_counter_sup.beam Deleted

guam-0.9.11.tar.gz/_build/default/lib/goldrush/ebin/gr_manager.beam Deleted

guam-0.9.11.tar.gz/_build/default/lib/goldrush/ebin/gr_manager_sup.beam Deleted

guam-0.9.11.tar.gz/_build/default/lib/goldrush/ebin/gr_param.beam Deleted

guam-0.9.11.tar.gz/_build/default/lib/goldrush/ebin/gr_param_sup.beam Deleted

guam-0.9.11.tar.gz/_build/default/lib/goldrush/ebin/gr_sup.beam Deleted

guam-0.9.11.tar.gz/_build/default/lib/goldrush/ebin/gre.beam Deleted

guam-0.9.11.tar.gz/_build/default/lib/kolab_guam Deleted

guam-0.9.11.tar.gz/_build/default/lib/kolab_guam/.rebar3 Deleted

guam-0.9.11.tar.gz/_build/default/lib/kolab_guam/.rebar3/rebar_compiler_erl Deleted

guam-0.9.11.tar.gz/_build/default/lib/kolab_guam/.rebar3/rebar_compiler_erl/source.dag Deleted

guam-0.9.11.tar.gz/_build/default/lib/kolab_guam/ebin Deleted

guam-0.9.11.tar.gz/_build/default/lib/kolab_guam/ebin/kolab_guam.app Deleted

guam-0.9.11.tar.gz/_build/default/lib/kolab_guam/ebin/kolab_guam.beam Deleted

guam-0.9.11.tar.gz/_build/default/lib/kolab_guam/ebin/kolab_guam_listener.beam Deleted

guam-0.9.11.tar.gz/_build/default/lib/kolab_guam/ebin/kolab_guam_rule.beam Deleted

guam-0.9.11.tar.gz/_build/default/lib/kolab_guam/ebin/kolab_guam_rule_audit.beam Deleted

guam-0.9.11.tar.gz/_build/default/lib/kolab_guam/ebin/kolab_guam_rule_filter_groupware.beam Deleted

guam-0.9.11.tar.gz/_build/default/lib/kolab_guam/ebin/kolab_guam_session.beam Deleted

guam-0.9.11.tar.gz/_build/default/lib/kolab_guam/ebin/kolab_guam_sup.beam Deleted

guam-0.9.11.tar.gz/_build/default/lib/kolab_guam/include Deleted

guam-0.9.11.tar.gz/_build/default/lib/kolab_guam/priv Deleted

guam-0.9.11.tar.gz/_build/default/lib/kolab_guam/src Deleted

guam-0.9.11.tar.gz/_build/default/lib/lager/.rebar3 Deleted

guam-0.9.11.tar.gz/_build/default/lib/lager/.rebar3/rebar_compiler_erl Deleted

guam-0.9.11.tar.gz/_build/default/lib/lager/.rebar3/rebar_compiler_erl/source.dag Deleted

guam-0.9.11.tar.gz/_build/default/lib/lager/ebin Deleted

guam-0.9.11.tar.gz/_build/default/lib/lager/ebin/error_logger_lager_h.beam Deleted

guam-0.9.11.tar.gz/_build/default/lib/lager/ebin/lager.app Deleted

@@ -1,38 +0,0 @@
-{application,lager,
-             [{description,"Erlang logging framework"},
-              {vsn,"3.9.2"},
-              {modules,[error_logger_lager_h,lager,lager_app,
-                        lager_backend_throttle,lager_common_test_backend,
-                        lager_config,lager_console_backend,lager_crash_log,
-                        lager_default_formatter,lager_file_backend,
-                        lager_format,lager_handler_watcher,
-                        lager_handler_watcher_sup,lager_manager_killer,
-                        lager_msg,lager_rotator_behaviour,
-                        lager_rotator_default,lager_stdlib,lager_sup,
-                        lager_transform,lager_trunc_io,lager_util]},
-              {applications,[kernel,stdlib,goldrush]},
-              {registered,[lager_sup,lager_event,lager_crash_log,
-                           lager_handler_watcher_sup]},
-              {mod,{lager_app,[]}},
-              {env,[{colored,false},
-                    {colors,[{debug,"\e[0;38m"},
-                             {info,"\e[1;37m"},
-                             {notice,"\e[1;36m"},
-                             {warning,"\e[1;33m"},
-                             {error,"\e[1;31m"},
-                             {critical,"\e[1;35m"},
-                             {alert,"\e[1;44m"},
-                             {emergency,"\e[1;41m"}]},
-                    {log_root,"log"},
-                    {crash_log,"crash.log"},
-                    {crash_log_msg_size,65536},
-                    {crash_log_size,10485760},
-                    {crash_log_date,"$D0"},
-                    {crash_log_count,5},
-                    {crash_log_rotator,lager_rotator_default},
-                    {error_logger_redirect,true},
-                    {error_logger_hwm,50},
-                    {async_threshold,20},
-                    {async_threshold_window,5}]},
-              {licenses,["Apache 2"]},
-              {links,[{"Github","https://github.com/erlang-lager/lager"}]}]}.

guam-0.9.11.tar.gz/_build/default/lib/lager/ebin/lager.beam Deleted

guam-0.9.11.tar.gz/_build/default/lib/lager/ebin/lager_app.beam Deleted

guam-0.9.11.tar.gz/_build/default/lib/lager/ebin/lager_backend_throttle.beam Deleted

guam-0.9.11.tar.gz/_build/default/lib/lager/ebin/lager_common_test_backend.beam Deleted

guam-0.9.11.tar.gz/_build/default/lib/lager/ebin/lager_config.beam Deleted

guam-0.9.11.tar.gz/_build/default/lib/lager/ebin/lager_console_backend.beam Deleted

guam-0.9.11.tar.gz/_build/default/lib/lager/ebin/lager_crash_log.beam Deleted

guam-0.9.11.tar.gz/_build/default/lib/lager/ebin/lager_default_formatter.beam Deleted

guam-0.9.11.tar.gz/_build/default/lib/lager/ebin/lager_file_backend.beam Deleted

guam-0.9.11.tar.gz/_build/default/lib/lager/ebin/lager_format.beam Deleted

guam-0.9.11.tar.gz/_build/default/lib/lager/ebin/lager_handler_watcher.beam Deleted

guam-0.9.11.tar.gz/_build/default/lib/lager/ebin/lager_handler_watcher_sup.beam Deleted

guam-0.9.11.tar.gz/_build/default/lib/lager/ebin/lager_manager_killer.beam Deleted

guam-0.9.11.tar.gz/_build/default/lib/lager/ebin/lager_msg.beam Deleted

guam-0.9.11.tar.gz/_build/default/lib/lager/ebin/lager_rotator_behaviour.beam Deleted

guam-0.9.11.tar.gz/_build/default/lib/lager/ebin/lager_rotator_default.beam Deleted

guam-0.9.11.tar.gz/_build/default/lib/lager/ebin/lager_stdlib.beam Deleted

guam-0.9.11.tar.gz/_build/default/lib/lager/ebin/lager_sup.beam Deleted

guam-0.9.11.tar.gz/_build/default/lib/lager/ebin/lager_transform.beam Deleted

guam-0.9.11.tar.gz/_build/default/lib/lager/ebin/lager_trunc_io.beam Deleted

guam-0.9.11.tar.gz/_build/default/lib/lager/ebin/lager_util.beam Deleted

guam-0.9.11.tar.gz/_build/default/lib/lager_syslog/.git Added

guam-0.9.11.tar.gz/_build/default/lib/lager_syslog/.git/HEAD Added

guam-0.9.11.tar.gz/_build/default/lib/lager_syslog/.git/branches Added

guam-0.9.11.tar.gz/_build/default/lib/lager_syslog/.git/config Added

guam-0.9.11.tar.gz/_build/default/lib/lager_syslog/.git/description Added

guam-0.9.11.tar.gz/_build/default/lib/lager_syslog/.git/hooks Added

guam-0.9.11.tar.gz/_build/default/lib/lager_syslog/.git/hooks/applypatch-msg.sample Added

guam-0.9.11.tar.gz/_build/default/lib/lager_syslog/.git/hooks/commit-msg.sample Added

guam-0.9.11.tar.gz/_build/default/lib/lager_syslog/.git/hooks/fsmonitor-watchman.sample Added

@@ -0,0 +1,173 @@
+#!/usr/bin/perl
+
+use strict;
+use warnings;
+use IPC::Open2;
+
+# An example hook script to integrate Watchman
+# (https://facebook.github.io/watchman/) with git to speed up detecting
+# new and modified files.
+#
+# The hook is passed a version (currently 2) and last update token
+# formatted as a string and outputs to stdout a new update token and
+# all files that have been modified since the update token. Paths must
+# be relative to the root of the working tree and separated by a single NUL.
+#
+# To enable this hook, rename this file to "query-watchman" and set
+# 'git config core.fsmonitor .git/hooks/query-watchman'
+#
+my ($version, $last_update_token) = @ARGV;
+
+# Uncomment for debugging
+# print STDERR "$0 $version $last_update_token\n";
+
+# Check the hook interface version
+if ($version ne 2) {
+	die "Unsupported query-fsmonitor hook version '$version'.\n" .
+	 "Falling back to scanning...\n";
+}
+
+my $git_work_tree = get_working_dir();
+
+my $retry = 1;
+
+my $json_pkg;
+eval {
+	require JSON::XS;
+	$json_pkg = "JSON::XS";
+	1;
+} or do {
+	require JSON::PP;
+	$json_pkg = "JSON::PP";
+};
+
+launch_watchman();
+
+sub launch_watchman {
+	my $o = watchman_query();
+	if (is_work_tree_watched($o)) {
+		output_result($o->{clock}, @{$o->{files}});
+	}
+}
+
+sub output_result {
+	my ($clockid, @files) = @_;
+
+	# Uncomment for debugging watchman output
+	# open (my $fh, ">", ".git/watchman-output.out");
+	# binmode $fh, ":utf8";
+	# print $fh "$clockid\n@files\n";
+	# close $fh;
+
+	binmode STDOUT, ":utf8";
+	print $clockid;
+	print "\0";
+	local $, = "\0";
+	print @files;
+}
+
+sub watchman_clock {
+	my $response = qx/watchman clock "$git_work_tree"/;
+	die "Failed to get clock id on '$git_work_tree'.\n" .
+		"Falling back to scanning...\n" if $? != 0;
+
+	return $json_pkg->new->utf8->decode($response);
+}
+
+sub watchman_query {
+	my $pid = open2(\*CHLD_OUT, \*CHLD_IN, 'watchman -j --no-pretty')
+	or die "open2() failed: $!\n" .
+	"Falling back to scanning...\n";
+
+	# In the query expression below we're asking for names of files that
+	# changed since $last_update_token but not from the .git folder.
+	#
+	# To accomplish this, we're using the "since" generator to use the
+	# recency index to select candidate nodes and "fields" to limit the
+	# output to file names only. Then we're using the "expression" term to
+	# further constrain the results.
+	if (substr($last_update_token, 0, 1) eq "c") {
+		$last_update_token = "\"$last_update_token\"";
+	}
+	my $query = <<"	END";
+		["query", "$git_work_tree", {
+			"since": $last_update_token,
+			"fields": ["name"],
+			"expression": ["not", ["dirname", ".git"]]
+		}]
+	END
+
+	# Uncomment for debugging the watchman query
+	# open (my $fh, ">", ".git/watchman-query.json");
+	# print $fh $query;
+	# close $fh;
+
+	print CHLD_IN $query;
+	close CHLD_IN;
+	my $response = do {local $/; <CHLD_OUT>};
+
+	# Uncomment for debugging the watch response
+	# open ($fh, ">", ".git/watchman-response.json");
+	# print $fh $response;
+	# close $fh;
+
+	die "Watchman: command returned no output.\n" .
+	"Falling back to scanning...\n" if $response eq "";
+	die "Watchman: command returned invalid output: $response\n" .
+	"Falling back to scanning...\n" unless $response =~ /^\{/;
+
+	return $json_pkg->new->utf8->decode($response);
+}
+
+sub is_work_tree_watched {
+	my ($output) = @_;
+	my $error = $output->{error};
+	if ($retry > 0 and $error and $error =~ m/unable to resolve root .* directory (.*) is not watched/) {
+		$retry--;
+		my $response = qx/watchman watch "$git_work_tree"/;
+		die "Failed to make watchman watch '$git_work_tree'.\n" .
+		 "Falling back to scanning...\n" if $? != 0;
+		$output = $json_pkg->new->utf8->decode($response);
+		$error = $output->{error};
+		die "Watchman: $error.\n" .
+		"Falling back to scanning...\n" if $error;
+
+		# Uncomment for debugging watchman output
+		# open (my $fh, ">", ".git/watchman-output.out");
+		# close $fh;
+
+		# Watchman will always return all files on the first query so
+		# return the fast "everything is dirty" flag to git and do the
+		# Watchman query just to get it over with now so we won't pay
+		# the cost in git to look up each individual file.
+		my $o = watchman_clock();
+		$error = $output->{error};
+
+		die "Watchman: $error.\n" .
+		"Falling back to scanning...\n" if $error;
+
+		output_result($o->{clock}, ("/"));
+		$last_update_token = $o->{clock};
+
+		eval { launch_watchman() };
+		return 0;
+	}
+
+	die "Watchman: $error.\n" .
+	"Falling back to scanning...\n" if $error;
+
+	return 1;
+}
+
+sub get_working_dir {
+	my $working_dir;
+	if ($^O =~ 'msys' || $^O =~ 'cygwin') {
+		$working_dir = Win32::GetCwd();
+		$working_dir =~ tr/\\/\//;
+	} else {
+		require Cwd;
+		$working_dir = Cwd::cwd();
+	}
+
+	return $working_dir;
+}

guam-0.9.11.tar.gz/_build/default/lib/lager_syslog/.git/hooks/post-update.sample Added

guam-0.9.11.tar.gz/_build/default/lib/lager_syslog/.git/hooks/pre-applypatch.sample Added

guam-0.9.11.tar.gz/_build/default/lib/lager_syslog/.git/hooks/pre-commit.sample Added

@@ -0,0 +1,49 @@
+#!/usr/bin/sh
+#
+# An example 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.
+#
+# To enable this hook, rename this file to "pre-commit".
+
+if git rev-parse --verify HEAD >/dev/null 2>&1
+then
+	against=HEAD
+else
+	# Initial commit: diff against an empty tree object
+	against=$(git hash-object -t tree /dev/null)
+fi
+
+# If you want to allow non-ASCII filenames set this variable to true.
+allownonascii=$(git config --type=bool hooks.allownonascii)
+
+# Redirect output to stderr.
+exec 1>&2
+
+# Cross platform projects tend to avoid non-ASCII filenames; prevent
+# them from being added to the repository. We exploit the fact that the
+# printable range starts at the space character and ends with tilde.
+if [ "$allownonascii" != "true" ] &&
+	# 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.
+	test $(git diff --cached --name-only --diff-filter=A -z $against |
+	 LC_ALL=C tr -d '[ -~]\0' | wc -c) != 0
+then
+	cat <<\EOF
+Error: Attempt to add a non-ASCII file name.
+
+This can cause problems if you want to work with people on other platforms.
+
+To be portable it is advisable to rename the file.
+
+If you know what you are doing you can disable this check using:
+
+ git config hooks.allownonascii true
+EOF
+	exit 1
+fi
+
+# If there are whitespace errors, print the offending file names and fail.
+exec git diff-index --check --cached $against --

guam-0.9.11.tar.gz/_build/default/lib/lager_syslog/.git/hooks/pre-merge-commit.sample Added

guam-0.9.11.tar.gz/_build/default/lib/lager_syslog/.git/hooks/pre-push.sample Added

@@ -0,0 +1,53 @@
+#!/usr/bin/sh
+
+# An example hook script to verify what is about to be pushed. Called by "git
+# push" after it has checked the remote status, but before anything has been
+# pushed. If this script exits with a non-zero status nothing will be pushed.
+#
+# This hook is called with the following parameters:
+#
+# $1 -- Name of the remote to which the push is being done
+# $2 -- URL to which the push is being done
+#
+# If pushing without using a named remote those arguments will be equal.
+#
+# Information about the commits which are being pushed is supplied as lines to
+# the standard input in the form:
+#
+# <local ref> <local oid> <remote ref> <remote oid>
+#
+# This sample shows how to prevent push of commits where the log message starts
+# with "WIP" (work in progress).
+
+remote="$1"
+url="$2"
+
+zero=$(git hash-object --stdin </dev/null | tr '[0-9a-f]' '0')
+
+while read local_ref local_oid remote_ref remote_oid
+do
+	if test "$local_oid" = "$zero"
+	then
+		# Handle delete
+		:
+	else
+		if test "$remote_oid" = "$zero"
+		then
+			# New branch, examine all commits
+			range="$local_oid"
+		else
+			# Update to existing branch, examine new commits
+			range="$remote_oid..$local_oid"
+		fi
+
+		# Check for WIP commit
+		commit=$(git rev-list -n 1 --grep '^WIP' "$range")
+		if test -n "$commit"
+		then
+			echo >&2 "Found WIP commit in $local_ref, not pushing"
+			exit 1
+		fi
+	fi
+done
+
+exit 0

guam-0.9.11.tar.gz/_build/default/lib/lager_syslog/.git/hooks/pre-rebase.sample Added

@@ -0,0 +1,169 @@
+#!/usr/bin/sh
+#
+# Copyright (c) 2006, 2008 Junio C Hamano
+#
+# The "pre-rebase" hook is run just before "git rebase" starts doing
+# its job, and can prevent the command from running by exiting with
+# non-zero status.
+#
+# The hook is called with the following parameters:
+#
+# $1 -- the upstream the series was forked from.
+# $2 -- the branch being rebased (or empty when rebasing the current branch).
+#
+# This sample shows how to prevent topic branches that are already
+# merged to 'next' branch from getting rebased, because allowing it
+# would result in rebasing already published history.
+
+publish=next
+basebranch="$1"
+if test "$#" = 2
+then
+	topic="refs/heads/$2"
+else
+	topic=`git symbolic-ref HEAD` ||
+	exit 0 ;# we do not interrupt rebasing detached HEAD
+fi
+
+case "$topic" in
+refs/heads/??/*)
+	;;
+*)
+	exit 0 ;# we do not interrupt others.
+	;;
+esac
+
+# Now we are dealing with a topic branch being rebased
+# on top of master. Is it OK to rebase it?
+
+# Does the topic really exist?
+git show-ref -q "$topic" || {
+	echo >&2 "No such branch $topic"
+	exit 1
+}
+
+# Is topic fully merged to master?
+not_in_master=`git rev-list --pretty=oneline ^master "$topic"`
+if test -z "$not_in_master"
+then
+	echo >&2 "$topic is fully merged to master; better remove it."
+	exit 1 ;# we could allow it, but there is no point.
+fi
+
+# Is topic ever merged to next? If so you should not be rebasing it.
+only_next_1=`git rev-list ^master "^$topic" ${publish} | sort`
+only_next_2=`git rev-list ^master ${publish} | sort`
+if test "$only_next_1" = "$only_next_2"
+then
+	not_in_topic=`git rev-list "^$topic" master`
+	if test -z "$not_in_topic"
+	then
+		echo >&2 "$topic is already up to date with master"
+		exit 1 ;# we could allow it, but there is no point.
+	else
+		exit 0
+	fi
+else
+	not_in_next=`git rev-list --pretty=oneline ^${publish} "$topic"`
+	/usr/bin/perl -e '
+		my $topic = $ARGV[0];
+		my $msg = "* $topic has commits already merged to public branch:\n";
+		my (%not_in_next) = map {
+			/^([0-9a-f]+) /;
+			($1 => 1);
+		} split(/\n/, $ARGV[1]);
+		for my $elem (map {
+				/^([0-9a-f]+) (.*)$/;
+				[$1 => $2];
+			} split(/\n/, $ARGV[2])) {
+			if (!exists $not_in_next{$elem->[0]}) {
+				if ($msg) {
+					print STDERR $msg;
+					undef $msg;
+				}
+				print STDERR " $elem->[1]\n";
+			}
+		}
+	' "$topic" "$not_in_next" "$not_in_master"
+	exit 1
+fi
+
+<<\DOC_END
+
+This sample hook safeguards topic branches that have been
+published from being rewound.
+
+The workflow assumed here is:
+
+ * Once a topic branch forks from "master", "master" is never
+ merged into it again (either directly or indirectly).
+
+ * Once a topic branch is fully cooked and merged into "master",
+ it is deleted. If you need to build on top of it to correct
+ earlier mistakes, a new topic branch is created by forking at
+ the tip of the "master". This is not strictly necessary, but
+ it makes it easier to keep your history simple.
+
+ * Whenever you need to test or publish your changes to topic
+ branches, merge them into "next" branch.
+
+The script, being an example, hardcodes the publish branch name
+to be "next", but it is trivial to make it configurable via
+$GIT_DIR/config mechanism.
+
+With this workflow, you would want to know:
+
+(1) ... if a topic branch has ever been merged to "next". Young
+ topic branches can have stupid mistakes you would rather
+ clean up before publishing, and things that have not been
+ merged into other branches can be easily rebased without
+ affecting other people. But once it is published, you would
+ not want to rewind it.
+
+(2) ... if a topic branch has been fully merged to "master".
+ Then you can delete it. More importantly, you should not
+ build on top of it -- other people may already want to
+ change things related to the topic as patches against your
+ "master", so if you need further changes, it is better to
+ fork the topic (perhaps with the same name) afresh from the
+ tip of "master".
+
+Let's look at this example:
+
+		 o---o---o---o---o---o---o---o---o---o "next"
+		 / / / /
+		 / a---a---b A / /
+		/ / / /
+	 / / c---c---c---c B /
+	 / / / \ /
+	 / / / b---b C \ /
+	 / / / / \ /
+ ---o---o---o---o---o---o---o---o---o---o---o "master"
+
+
+A, B and C are topic branches.
+
+ * A has one fix since it was merged up to "next".
+
+ * B has finished. It has been fully merged up to "master" and "next",
+ and is ready to be deleted.
+
+ * C has not merged to "next" at all.
+
+We would want to allow C to be rebased, refuse A, and encourage
+B to be deleted.
+
+To compute (1):
+
+	git rev-list ^master ^topic next
+	git rev-list ^master next
+
+	if these match, topic has not merged in next at all.
+
+To compute (2):
+
+	git rev-list master..topic
+
+	if this is empty, it is fully merged to "master".
+
+DOC_END

guam-0.9.11.tar.gz/_build/default/lib/lager_syslog/.git/hooks/pre-receive.sample Added

guam-0.9.11.tar.gz/_build/default/lib/lager_syslog/.git/hooks/prepare-commit-msg.sample Added

@@ -0,0 +1,42 @@
+#!/usr/bin/sh
+#
+# An example hook script to prepare the commit log message.
+# Called by "git commit" with the name of the file that has the
+# commit message, followed by the description of the commit
+# message's source.  The hook's purpose is to edit the commit
+# message file.  If the hook fails with a non-zero status,
+# the commit is aborted.
+#
+# To enable this hook, rename this file to "prepare-commit-msg".
+
+# This hook includes three examples. The first one removes the
+# "# Please enter the commit message..." help message.
+#
+# The second includes the output of "git diff --name-status -r"
+# into the message, just before the "git status" output.  It is
+# commented because it doesn't cope with --amend or with squashed
+# commits.
+#
+# The third example adds a Signed-off-by line to the message, that can
+# still be edited.  This is rarely a good idea.
+
+COMMIT_MSG_FILE=$1
+COMMIT_SOURCE=$2
+SHA1=$3
+
+/usr/bin/perl -i.bak -ne 'print unless(m/^. Please enter the commit message/..m/^#$/)' "$COMMIT_MSG_FILE"
+
+# case "$COMMIT_SOURCE,$SHA1" in
+#  ,|template,)
+#    /usr/bin/perl -i.bak -pe '
+#       print "\n" . `git diff --cached --name-status -r`
+# 	 if /^#/ && $first++ == 0' "$COMMIT_MSG_FILE" ;;
+#  *) ;;
+# esac
+
+# SOB=$(git var GIT_COMMITTER_IDENT | sed -n 's/^$.*>$.*$/Signed-off-by: \1/p')
+# git interpret-trailers --in-place --trailer "$SOB" "$COMMIT_MSG_FILE"
+# if test -z "$COMMIT_SOURCE"
+# then
+#   /usr/bin/perl -i.bak -pe 'print "\n" if !$first_line++' "$COMMIT_MSG_FILE"
+# fi

guam-0.9.11.tar.gz/_build/default/lib/lager_syslog/.git/hooks/push-to-checkout.sample Added

@@ -0,0 +1,78 @@
+#!/usr/bin/sh
+
+# An example hook script to update a checked-out tree on a git push.
+#
+# This hook is invoked by git-receive-pack(1) when it reacts to git
+# push and updates reference(s) in its repository, and when the push
+# tries to update the branch that is currently checked out and the
+# receive.denyCurrentBranch configuration variable is set to
+# updateInstead.
+#
+# By default, such a push is refused if the working tree and the index
+# of the remote repository has any difference from the currently
+# checked out commit; when both the working tree and the index match
+# the current commit, they are updated to match the newly pushed tip
+# of the branch. This hook is to be used to override the default
+# behaviour; however the code below reimplements the default behaviour
+# as a starting point for convenient modification.
+#
+# The hook receives the commit with which the tip of the current
+# branch is going to be updated:
+commit=$1
+
+# It can exit with a non-zero status to refuse the push (when it does
+# so, it must not modify the index or the working tree).
+die () {
+	echo >&2 "$*"
+	exit 1
+}
+
+# Or it can make any necessary changes to the working tree and to the
+# index to bring them to the desired state when the tip of the current
+# branch is updated to the new commit, and exit with a zero status.
+#
+# For example, the hook can simply run git read-tree -u -m HEAD "$1"
+# in order to emulate git fetch that is run in the reverse direction
+# with git push, as the two-tree form of git read-tree -u -m is
+# essentially the same as git switch or git checkout that switches
+# branches while keeping the local changes in the working tree that do
+# not interfere with the difference between the branches.
+
+# The below is a more-or-less exact translation to shell of the C code
+# for the default behaviour for git's push-to-checkout hook defined in
+# the push_to_deploy() function in builtin/receive-pack.c.
+#
+# Note that the hook will be executed from the repository directory,
+# not from the working tree, so if you want to perform operations on
+# the working tree, you will have to adapt your code accordingly, e.g.
+# by adding "cd .." or using relative paths.
+
+if ! git update-index -q --ignore-submodules --refresh
+then
+	die "Up-to-date check failed"
+fi
+
+if ! git diff-files --quiet --ignore-submodules --
+then
+	die "Working directory has unstaged changes"
+fi
+
+# This is a rough translation of:
+#
+# head_has_history() ? "HEAD" : EMPTY_TREE_SHA1_HEX
+if git cat-file -e HEAD 2>/dev/null
+then
+	head=HEAD
+else
+	head=$(git hash-object -t tree --stdin </dev/null)
+fi
+
+if ! git diff-index --quiet --cached --ignore-submodules $head --
+then
+	die "Working directory has staged changes"
+fi
+
+if ! git read-tree -u -m "$commit"
+then
+	die "Could not update working tree to new HEAD"
+fi

guam-0.9.11.tar.gz/_build/default/lib/lager_syslog/.git/hooks/update.sample Added

@@ -0,0 +1,128 @@
+#!/usr/bin/sh
+#
+# An example hook script to block unannotated tags from entering.
+# Called by "git receive-pack" with arguments: refname sha1-old sha1-new
+#
+# To enable this hook, rename this file to "update".
+#
+# Config
+# ------
+# hooks.allowunannotated
+# This boolean sets whether unannotated tags will be allowed into the
+# repository. By default they won't be.
+# hooks.allowdeletetag
+# This boolean sets whether deleting tags will be allowed in the
+# repository. By default they won't be.
+# hooks.allowmodifytag
+# This boolean sets whether a tag may be modified after creation. By default
+# it won't be.
+# hooks.allowdeletebranch
+# This boolean sets whether deleting branches will be allowed in the
+# repository. By default they won't be.
+# hooks.denycreatebranch
+# This boolean sets whether remotely creating branches will be denied
+# in the repository. By default this is allowed.
+#
+
+# --- Command line
+refname="$1"
+oldrev="$2"
+newrev="$3"
+
+# --- Safety check
+if [ -z "$GIT_DIR" ]; then
+	echo "Don't run this script from the command line." >&2
+	echo " (if you want, you could supply GIT_DIR then run" >&2
+	echo " $0 <ref> <oldrev> <newrev>)" >&2
+	exit 1
+fi
+
+if [ -z "$refname" -o -z "$oldrev" -o -z "$newrev" ]; then
+	echo "usage: $0 <ref> <oldrev> <newrev>" >&2
+	exit 1
+fi
+
+# --- Config
+allowunannotated=$(git config --type=bool hooks.allowunannotated)
+allowdeletebranch=$(git config --type=bool hooks.allowdeletebranch)
+denycreatebranch=$(git config --type=bool hooks.denycreatebranch)
+allowdeletetag=$(git config --type=bool hooks.allowdeletetag)
+allowmodifytag=$(git config --type=bool hooks.allowmodifytag)
+
+# check for no description
+projectdesc=$(sed -e '1q' "$GIT_DIR/description")
+case "$projectdesc" in
+"Unnamed repository"* | "")
+	echo "*** Project description file hasn't been set" >&2
+	exit 1
+	;;
+esac
+
+# --- Check types
+# if $newrev is 0000...0000, it's a commit to delete a ref.
+zero=$(git hash-object --stdin </dev/null | tr '[0-9a-f]' '0')
+if [ "$newrev" = "$zero" ]; then
+	newrev_type=delete
+else
+	newrev_type=$(git cat-file -t $newrev)
+fi
+
+case "$refname","$newrev_type" in
+	refs/tags/*,commit)
+		# un-annotated tag
+		short_refname=${refname##refs/tags/}
+		if [ "$allowunannotated" != "true" ]; then
+			echo "*** The un-annotated tag, $short_refname, is not allowed in this repository" >&2
+			echo "*** Use 'git tag [ -a | -s ]' for tags you want to propagate." >&2
+			exit 1
+		fi
+		;;
+	refs/tags/*,delete)
+		# delete tag
+		if [ "$allowdeletetag" != "true" ]; then
+			echo "*** Deleting a tag is not allowed in this repository" >&2
+			exit 1
+		fi
+		;;
+	refs/tags/*,tag)
+		# annotated tag
+		if [ "$allowmodifytag" != "true" ] && git rev-parse $refname > /dev/null 2>&1
+		then
+			echo "*** Tag '$refname' already exists." >&2
+			echo "*** Modifying a tag is not allowed in this repository." >&2
+			exit 1
+		fi
+		;;
+	refs/heads/*,commit)
+		# branch
+		if [ "$oldrev" = "$zero" -a "$denycreatebranch" = "true" ]; then
+			echo "*** Creating a branch is not allowed in this repository" >&2
+			exit 1
+		fi
+		;;
+	refs/heads/*,delete)
+		# delete branch
+		if [ "$allowdeletebranch" != "true" ]; then
+			echo "*** Deleting a branch is not allowed in this repository" >&2
+			exit 1
+		fi
+		;;
+	refs/remotes/*,commit)
+		# tracking branch
+		;;
+	refs/remotes/*,delete)
+		# delete tracking branch
+		if [ "$allowdeletebranch" != "true" ]; then
+			echo "*** Deleting a tracking branch is not allowed in this repository" >&2
+			exit 1
+		fi
+		;;
+	*)
+		# Anything else (is there anything else?)
+		echo "*** Update hook: unknown type of update to ref $refname of type $newrev_type" >&2
+		exit 1
+		;;
+esac
+
+# --- Finished
+exit 0

guam-0.9.11.tar.gz/_build/default/lib/lager_syslog/.git/index Added

guam-0.9.11.tar.gz/_build/default/lib/lager_syslog/.git/info Added

guam-0.9.11.tar.gz/_build/default/lib/lager_syslog/.git/info/exclude Added

guam-0.9.11.tar.gz/_build/default/lib/lager_syslog/.git/logs Added

guam-0.9.11.tar.gz/_build/default/lib/lager_syslog/.git/logs/HEAD Added

guam-0.9.11.tar.gz/_build/default/lib/lager_syslog/.git/objects Added

guam-0.9.11.tar.gz/_build/default/lib/lager_syslog/.git/objects/info Added

guam-0.9.11.tar.gz/_build/default/lib/lager_syslog/.git/objects/pack Added

guam-0.9.11.tar.gz/_build/default/lib/lager_syslog/.git/objects/pack/pack-fd92f774b6c37e398e2e1178b7a16ee6a239a885.idx Added

guam-0.9.11.tar.gz/_build/default/lib/lager_syslog/.git/objects/pack/pack-fd92f774b6c37e398e2e1178b7a16ee6a239a885.pack Added

guam-0.9.11.tar.gz/_build/default/lib/lager_syslog/.git/packed-refs Added

guam-0.9.11.tar.gz/_build/default/lib/lager_syslog/.git/refs Added

guam-0.9.11.tar.gz/_build/default/lib/lager_syslog/.git/refs/heads Added

guam-0.9.11.tar.gz/_build/default/lib/lager_syslog/.git/refs/tags Added

guam-0.9.11.tar.gz/_build/default/lib/lager_syslog/.git/refs/tags/1.2.1 Added

guam-0.9.11.tar.gz/_build/default/lib/lager_syslog/.rebar3 Deleted

guam-0.9.11.tar.gz/_build/default/lib/lager_syslog/.rebar3/rebar_compiler_erl Deleted

guam-0.9.11.tar.gz/_build/default/lib/lager_syslog/.rebar3/rebar_compiler_erl/source.dag Deleted

guam-0.9.11.tar.gz/_build/default/lib/lager_syslog/ebin Deleted

guam-0.9.11.tar.gz/_build/default/lib/lager_syslog/ebin/lager_syslog.app Deleted

guam-0.9.11.tar.gz/_build/default/lib/lager_syslog/ebin/lager_syslog_backend.beam Deleted

guam-0.9.11.tar.gz/_build/default/lib/syslog/.git Added

guam-0.9.11.tar.gz/_build/default/lib/syslog/.git/HEAD Added

guam-0.9.11.tar.gz/_build/default/lib/syslog/.git/branches Added

guam-0.9.11.tar.gz/_build/default/lib/syslog/.git/config Added

guam-0.9.11.tar.gz/_build/default/lib/syslog/.git/description Added

guam-0.9.11.tar.gz/_build/default/lib/syslog/.git/hooks Added

guam-0.9.11.tar.gz/_build/default/lib/syslog/.git/hooks/applypatch-msg.sample Added

guam-0.9.11.tar.gz/_build/default/lib/syslog/.git/hooks/commit-msg.sample Added

guam-0.9.11.tar.gz/_build/default/lib/syslog/.git/hooks/fsmonitor-watchman.sample Added

@@ -0,0 +1,173 @@
+#!/usr/bin/perl
+
+use strict;
+use warnings;
+use IPC::Open2;
+
+# An example hook script to integrate Watchman
+# (https://facebook.github.io/watchman/) with git to speed up detecting
+# new and modified files.
+#
+# The hook is passed a version (currently 2) and last update token
+# formatted as a string and outputs to stdout a new update token and
+# all files that have been modified since the update token. Paths must
+# be relative to the root of the working tree and separated by a single NUL.
+#
+# To enable this hook, rename this file to "query-watchman" and set
+# 'git config core.fsmonitor .git/hooks/query-watchman'
+#
+my ($version, $last_update_token) = @ARGV;
+
+# Uncomment for debugging
+# print STDERR "$0 $version $last_update_token\n";
+
+# Check the hook interface version
+if ($version ne 2) {
+	die "Unsupported query-fsmonitor hook version '$version'.\n" .
+	 "Falling back to scanning...\n";
+}
+
+my $git_work_tree = get_working_dir();
+
+my $retry = 1;
+
+my $json_pkg;
+eval {
+	require JSON::XS;
+	$json_pkg = "JSON::XS";
+	1;
+} or do {
+	require JSON::PP;
+	$json_pkg = "JSON::PP";
+};
+
+launch_watchman();
+
+sub launch_watchman {
+	my $o = watchman_query();
+	if (is_work_tree_watched($o)) {
+		output_result($o->{clock}, @{$o->{files}});
+	}
+}
+
+sub output_result {
+	my ($clockid, @files) = @_;
+
+	# Uncomment for debugging watchman output
+	# open (my $fh, ">", ".git/watchman-output.out");
+	# binmode $fh, ":utf8";
+	# print $fh "$clockid\n@files\n";
+	# close $fh;
+
+	binmode STDOUT, ":utf8";
+	print $clockid;
+	print "\0";
+	local $, = "\0";
+	print @files;
+}
+
+sub watchman_clock {
+	my $response = qx/watchman clock "$git_work_tree"/;
+	die "Failed to get clock id on '$git_work_tree'.\n" .
+		"Falling back to scanning...\n" if $? != 0;
+
+	return $json_pkg->new->utf8->decode($response);
+}
+
+sub watchman_query {
+	my $pid = open2(\*CHLD_OUT, \*CHLD_IN, 'watchman -j --no-pretty')
+	or die "open2() failed: $!\n" .
+	"Falling back to scanning...\n";
+
+	# In the query expression below we're asking for names of files that
+	# changed since $last_update_token but not from the .git folder.
+	#
+	# To accomplish this, we're using the "since" generator to use the
+	# recency index to select candidate nodes and "fields" to limit the
+	# output to file names only. Then we're using the "expression" term to
+	# further constrain the results.
+	if (substr($last_update_token, 0, 1) eq "c") {
+		$last_update_token = "\"$last_update_token\"";
+	}
+	my $query = <<"	END";
+		["query", "$git_work_tree", {
+			"since": $last_update_token,
+			"fields": ["name"],
+			"expression": ["not", ["dirname", ".git"]]
+		}]
+	END
+
+	# Uncomment for debugging the watchman query
+	# open (my $fh, ">", ".git/watchman-query.json");
+	# print $fh $query;
+	# close $fh;
+
+	print CHLD_IN $query;
+	close CHLD_IN;
+	my $response = do {local $/; <CHLD_OUT>};
+
+	# Uncomment for debugging the watch response
+	# open ($fh, ">", ".git/watchman-response.json");
+	# print $fh $response;
+	# close $fh;
+
+	die "Watchman: command returned no output.\n" .
+	"Falling back to scanning...\n" if $response eq "";
+	die "Watchman: command returned invalid output: $response\n" .
+	"Falling back to scanning...\n" unless $response =~ /^\{/;
+
+	return $json_pkg->new->utf8->decode($response);
+}
+
+sub is_work_tree_watched {
+	my ($output) = @_;
+	my $error = $output->{error};
+	if ($retry > 0 and $error and $error =~ m/unable to resolve root .* directory (.*) is not watched/) {
+		$retry--;
+		my $response = qx/watchman watch "$git_work_tree"/;
+		die "Failed to make watchman watch '$git_work_tree'.\n" .
+		 "Falling back to scanning...\n" if $? != 0;
+		$output = $json_pkg->new->utf8->decode($response);
+		$error = $output->{error};
+		die "Watchman: $error.\n" .
+		"Falling back to scanning...\n" if $error;
+
+		# Uncomment for debugging watchman output
+		# open (my $fh, ">", ".git/watchman-output.out");
+		# close $fh;
+
+		# Watchman will always return all files on the first query so
+		# return the fast "everything is dirty" flag to git and do the
+		# Watchman query just to get it over with now so we won't pay
+		# the cost in git to look up each individual file.
+		my $o = watchman_clock();
+		$error = $output->{error};
+
+		die "Watchman: $error.\n" .
+		"Falling back to scanning...\n" if $error;
+
+		output_result($o->{clock}, ("/"));
+		$last_update_token = $o->{clock};
+
+		eval { launch_watchman() };
+		return 0;
+	}
+
+	die "Watchman: $error.\n" .
+	"Falling back to scanning...\n" if $error;
+
+	return 1;
+}
+
+sub get_working_dir {
+	my $working_dir;
+	if ($^O =~ 'msys' || $^O =~ 'cygwin') {
+		$working_dir = Win32::GetCwd();
+		$working_dir =~ tr/\\/\//;
+	} else {
+		require Cwd;
+		$working_dir = Cwd::cwd();
+	}
+
+	return $working_dir;
+}

guam-0.9.11.tar.gz/_build/default/lib/syslog/.git/hooks/post-update.sample Added

guam-0.9.11.tar.gz/_build/default/lib/syslog/.git/hooks/pre-applypatch.sample Added

guam-0.9.11.tar.gz/_build/default/lib/syslog/.git/hooks/pre-commit.sample Added

@@ -0,0 +1,49 @@
+#!/usr/bin/sh
+#
+# An example 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.
+#
+# To enable this hook, rename this file to "pre-commit".
+
+if git rev-parse --verify HEAD >/dev/null 2>&1
+then
+	against=HEAD
+else
+	# Initial commit: diff against an empty tree object
+	against=$(git hash-object -t tree /dev/null)
+fi
+
+# If you want to allow non-ASCII filenames set this variable to true.
+allownonascii=$(git config --type=bool hooks.allownonascii)
+
+# Redirect output to stderr.
+exec 1>&2
+
+# Cross platform projects tend to avoid non-ASCII filenames; prevent
+# them from being added to the repository. We exploit the fact that the
+# printable range starts at the space character and ends with tilde.
+if [ "$allownonascii" != "true" ] &&
+	# 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.
+	test $(git diff --cached --name-only --diff-filter=A -z $against |
+	 LC_ALL=C tr -d '[ -~]\0' | wc -c) != 0
+then
+	cat <<\EOF
+Error: Attempt to add a non-ASCII file name.
+
+This can cause problems if you want to work with people on other platforms.
+
+To be portable it is advisable to rename the file.
+
+If you know what you are doing you can disable this check using:
+
+ git config hooks.allownonascii true
+EOF
+	exit 1
+fi
+
+# If there are whitespace errors, print the offending file names and fail.
+exec git diff-index --check --cached $against --

guam-0.9.11.tar.gz/_build/default/lib/syslog/.git/hooks/pre-merge-commit.sample Added

guam-0.9.11.tar.gz/_build/default/lib/syslog/.git/hooks/pre-push.sample Added

@@ -0,0 +1,53 @@
+#!/usr/bin/sh
+
+# An example hook script to verify what is about to be pushed. Called by "git
+# push" after it has checked the remote status, but before anything has been
+# pushed. If this script exits with a non-zero status nothing will be pushed.
+#
+# This hook is called with the following parameters:
+#
+# $1 -- Name of the remote to which the push is being done
+# $2 -- URL to which the push is being done
+#
+# If pushing without using a named remote those arguments will be equal.
+#
+# Information about the commits which are being pushed is supplied as lines to
+# the standard input in the form:
+#
+# <local ref> <local oid> <remote ref> <remote oid>
+#
+# This sample shows how to prevent push of commits where the log message starts
+# with "WIP" (work in progress).
+
+remote="$1"
+url="$2"
+
+zero=$(git hash-object --stdin </dev/null | tr '[0-9a-f]' '0')
+
+while read local_ref local_oid remote_ref remote_oid
+do
+	if test "$local_oid" = "$zero"
+	then
+		# Handle delete
+		:
+	else
+		if test "$remote_oid" = "$zero"
+		then
+			# New branch, examine all commits
+			range="$local_oid"
+		else
+			# Update to existing branch, examine new commits
+			range="$remote_oid..$local_oid"
+		fi
+
+		# Check for WIP commit
+		commit=$(git rev-list -n 1 --grep '^WIP' "$range")
+		if test -n "$commit"
+		then
+			echo >&2 "Found WIP commit in $local_ref, not pushing"
+			exit 1
+		fi
+	fi
+done
+
+exit 0

guam-0.9.11.tar.gz/_build/default/lib/syslog/.git/hooks/pre-rebase.sample Added

@@ -0,0 +1,169 @@
+#!/usr/bin/sh
+#
+# Copyright (c) 2006, 2008 Junio C Hamano
+#
+# The "pre-rebase" hook is run just before "git rebase" starts doing
+# its job, and can prevent the command from running by exiting with
+# non-zero status.
+#
+# The hook is called with the following parameters:
+#
+# $1 -- the upstream the series was forked from.
+# $2 -- the branch being rebased (or empty when rebasing the current branch).
+#
+# This sample shows how to prevent topic branches that are already
+# merged to 'next' branch from getting rebased, because allowing it
+# would result in rebasing already published history.
+
+publish=next
+basebranch="$1"
+if test "$#" = 2
+then
+	topic="refs/heads/$2"
+else
+	topic=`git symbolic-ref HEAD` ||
+	exit 0 ;# we do not interrupt rebasing detached HEAD
+fi
+
+case "$topic" in
+refs/heads/??/*)
+	;;
+*)
+	exit 0 ;# we do not interrupt others.
+	;;
+esac
+
+# Now we are dealing with a topic branch being rebased
+# on top of master. Is it OK to rebase it?
+
+# Does the topic really exist?
+git show-ref -q "$topic" || {
+	echo >&2 "No such branch $topic"
+	exit 1
+}
+
+# Is topic fully merged to master?
+not_in_master=`git rev-list --pretty=oneline ^master "$topic"`
+if test -z "$not_in_master"
+then
+	echo >&2 "$topic is fully merged to master; better remove it."
+	exit 1 ;# we could allow it, but there is no point.
+fi
+
+# Is topic ever merged to next? If so you should not be rebasing it.
+only_next_1=`git rev-list ^master "^$topic" ${publish} | sort`
+only_next_2=`git rev-list ^master ${publish} | sort`
+if test "$only_next_1" = "$only_next_2"
+then
+	not_in_topic=`git rev-list "^$topic" master`
+	if test -z "$not_in_topic"
+	then
+		echo >&2 "$topic is already up to date with master"
+		exit 1 ;# we could allow it, but there is no point.
+	else
+		exit 0
+	fi
+else
+	not_in_next=`git rev-list --pretty=oneline ^${publish} "$topic"`
+	/usr/bin/perl -e '
+		my $topic = $ARGV[0];
+		my $msg = "* $topic has commits already merged to public branch:\n";
+		my (%not_in_next) = map {
+			/^([0-9a-f]+) /;
+			($1 => 1);
+		} split(/\n/, $ARGV[1]);
+		for my $elem (map {
+				/^([0-9a-f]+) (.*)$/;
+				[$1 => $2];
+			} split(/\n/, $ARGV[2])) {
+			if (!exists $not_in_next{$elem->[0]}) {
+				if ($msg) {
+					print STDERR $msg;
+					undef $msg;
+				}
+				print STDERR " $elem->[1]\n";
+			}
+		}
+	' "$topic" "$not_in_next" "$not_in_master"
+	exit 1
+fi
+
+<<\DOC_END
+
+This sample hook safeguards topic branches that have been
+published from being rewound.
+
+The workflow assumed here is:
+
+ * Once a topic branch forks from "master", "master" is never
+ merged into it again (either directly or indirectly).
+
+ * Once a topic branch is fully cooked and merged into "master",
+ it is deleted. If you need to build on top of it to correct
+ earlier mistakes, a new topic branch is created by forking at
+ the tip of the "master". This is not strictly necessary, but
+ it makes it easier to keep your history simple.
+
+ * Whenever you need to test or publish your changes to topic
+ branches, merge them into "next" branch.
+
+The script, being an example, hardcodes the publish branch name
+to be "next", but it is trivial to make it configurable via
+$GIT_DIR/config mechanism.
+
+With this workflow, you would want to know:
+
+(1) ... if a topic branch has ever been merged to "next". Young
+ topic branches can have stupid mistakes you would rather
+ clean up before publishing, and things that have not been
+ merged into other branches can be easily rebased without
+ affecting other people. But once it is published, you would
+ not want to rewind it.
+
+(2) ... if a topic branch has been fully merged to "master".
+ Then you can delete it. More importantly, you should not
+ build on top of it -- other people may already want to
+ change things related to the topic as patches against your
+ "master", so if you need further changes, it is better to
+ fork the topic (perhaps with the same name) afresh from the
+ tip of "master".
+
+Let's look at this example:
+
+		 o---o---o---o---o---o---o---o---o---o "next"
+		 / / / /
+		 / a---a---b A / /
+		/ / / /
+	 / / c---c---c---c B /
+	 / / / \ /
+	 / / / b---b C \ /
+	 / / / / \ /
+ ---o---o---o---o---o---o---o---o---o---o---o "master"
+
+
+A, B and C are topic branches.
+
+ * A has one fix since it was merged up to "next".
+
+ * B has finished. It has been fully merged up to "master" and "next",
+ and is ready to be deleted.
+
+ * C has not merged to "next" at all.
+
+We would want to allow C to be rebased, refuse A, and encourage
+B to be deleted.
+
+To compute (1):
+
+	git rev-list ^master ^topic next
+	git rev-list ^master next
+
+	if these match, topic has not merged in next at all.
+
+To compute (2):
+
+	git rev-list master..topic
+
+	if this is empty, it is fully merged to "master".
+
+DOC_END

guam-0.9.11.tar.gz/_build/default/lib/syslog/.git/hooks/pre-receive.sample Added

guam-0.9.11.tar.gz/_build/default/lib/syslog/.git/hooks/prepare-commit-msg.sample Added

@@ -0,0 +1,42 @@
+#!/usr/bin/sh
+#
+# An example hook script to prepare the commit log message.
+# Called by "git commit" with the name of the file that has the
+# commit message, followed by the description of the commit
+# message's source.  The hook's purpose is to edit the commit
+# message file.  If the hook fails with a non-zero status,
+# the commit is aborted.
+#
+# To enable this hook, rename this file to "prepare-commit-msg".
+
+# This hook includes three examples. The first one removes the
+# "# Please enter the commit message..." help message.
+#
+# The second includes the output of "git diff --name-status -r"
+# into the message, just before the "git status" output.  It is
+# commented because it doesn't cope with --amend or with squashed
+# commits.
+#
+# The third example adds a Signed-off-by line to the message, that can
+# still be edited.  This is rarely a good idea.
+
+COMMIT_MSG_FILE=$1
+COMMIT_SOURCE=$2
+SHA1=$3
+
+/usr/bin/perl -i.bak -ne 'print unless(m/^. Please enter the commit message/..m/^#$/)' "$COMMIT_MSG_FILE"
+
+# case "$COMMIT_SOURCE,$SHA1" in
+#  ,|template,)
+#    /usr/bin/perl -i.bak -pe '
+#       print "\n" . `git diff --cached --name-status -r`
+# 	 if /^#/ && $first++ == 0' "$COMMIT_MSG_FILE" ;;
+#  *) ;;
+# esac
+
+# SOB=$(git var GIT_COMMITTER_IDENT | sed -n 's/^$.*>$.*$/Signed-off-by: \1/p')
+# git interpret-trailers --in-place --trailer "$SOB" "$COMMIT_MSG_FILE"
+# if test -z "$COMMIT_SOURCE"
+# then
+#   /usr/bin/perl -i.bak -pe 'print "\n" if !$first_line++' "$COMMIT_MSG_FILE"
+# fi

guam-0.9.11.tar.gz/_build/default/lib/syslog/.git/hooks/push-to-checkout.sample Added

@@ -0,0 +1,78 @@
+#!/usr/bin/sh
+
+# An example hook script to update a checked-out tree on a git push.
+#
+# This hook is invoked by git-receive-pack(1) when it reacts to git
+# push and updates reference(s) in its repository, and when the push
+# tries to update the branch that is currently checked out and the
+# receive.denyCurrentBranch configuration variable is set to
+# updateInstead.
+#
+# By default, such a push is refused if the working tree and the index
+# of the remote repository has any difference from the currently
+# checked out commit; when both the working tree and the index match
+# the current commit, they are updated to match the newly pushed tip
+# of the branch. This hook is to be used to override the default
+# behaviour; however the code below reimplements the default behaviour
+# as a starting point for convenient modification.
+#
+# The hook receives the commit with which the tip of the current
+# branch is going to be updated:
+commit=$1
+
+# It can exit with a non-zero status to refuse the push (when it does
+# so, it must not modify the index or the working tree).
+die () {
+	echo >&2 "$*"
+	exit 1
+}
+
+# Or it can make any necessary changes to the working tree and to the
+# index to bring them to the desired state when the tip of the current
+# branch is updated to the new commit, and exit with a zero status.
+#
+# For example, the hook can simply run git read-tree -u -m HEAD "$1"
+# in order to emulate git fetch that is run in the reverse direction
+# with git push, as the two-tree form of git read-tree -u -m is
+# essentially the same as git switch or git checkout that switches
+# branches while keeping the local changes in the working tree that do
+# not interfere with the difference between the branches.
+
+# The below is a more-or-less exact translation to shell of the C code
+# for the default behaviour for git's push-to-checkout hook defined in
+# the push_to_deploy() function in builtin/receive-pack.c.
+#
+# Note that the hook will be executed from the repository directory,
+# not from the working tree, so if you want to perform operations on
+# the working tree, you will have to adapt your code accordingly, e.g.
+# by adding "cd .." or using relative paths.
+
+if ! git update-index -q --ignore-submodules --refresh
+then
+	die "Up-to-date check failed"
+fi
+
+if ! git diff-files --quiet --ignore-submodules --
+then
+	die "Working directory has unstaged changes"
+fi
+
+# This is a rough translation of:
+#
+# head_has_history() ? "HEAD" : EMPTY_TREE_SHA1_HEX
+if git cat-file -e HEAD 2>/dev/null
+then
+	head=HEAD
+else
+	head=$(git hash-object -t tree --stdin </dev/null)
+fi
+
+if ! git diff-index --quiet --cached --ignore-submodules $head --
+then
+	die "Working directory has staged changes"
+fi
+
+if ! git read-tree -u -m "$commit"
+then
+	die "Could not update working tree to new HEAD"
+fi

guam-0.9.11.tar.gz/_build/default/lib/syslog/.git/hooks/update.sample Added

@@ -0,0 +1,128 @@
+#!/usr/bin/sh
+#
+# An example hook script to block unannotated tags from entering.
+# Called by "git receive-pack" with arguments: refname sha1-old sha1-new
+#
+# To enable this hook, rename this file to "update".
+#
+# Config
+# ------
+# hooks.allowunannotated
+# This boolean sets whether unannotated tags will be allowed into the
+# repository. By default they won't be.
+# hooks.allowdeletetag
+# This boolean sets whether deleting tags will be allowed in the
+# repository. By default they won't be.
+# hooks.allowmodifytag
+# This boolean sets whether a tag may be modified after creation. By default
+# it won't be.
+# hooks.allowdeletebranch
+# This boolean sets whether deleting branches will be allowed in the
+# repository. By default they won't be.
+# hooks.denycreatebranch
+# This boolean sets whether remotely creating branches will be denied
+# in the repository. By default this is allowed.
+#
+
+# --- Command line
+refname="$1"
+oldrev="$2"
+newrev="$3"
+
+# --- Safety check
+if [ -z "$GIT_DIR" ]; then
+	echo "Don't run this script from the command line." >&2
+	echo " (if you want, you could supply GIT_DIR then run" >&2
+	echo " $0 <ref> <oldrev> <newrev>)" >&2
+	exit 1
+fi
+
+if [ -z "$refname" -o -z "$oldrev" -o -z "$newrev" ]; then
+	echo "usage: $0 <ref> <oldrev> <newrev>" >&2
+	exit 1
+fi
+
+# --- Config
+allowunannotated=$(git config --type=bool hooks.allowunannotated)
+allowdeletebranch=$(git config --type=bool hooks.allowdeletebranch)
+denycreatebranch=$(git config --type=bool hooks.denycreatebranch)
+allowdeletetag=$(git config --type=bool hooks.allowdeletetag)
+allowmodifytag=$(git config --type=bool hooks.allowmodifytag)
+
+# check for no description
+projectdesc=$(sed -e '1q' "$GIT_DIR/description")
+case "$projectdesc" in
+"Unnamed repository"* | "")
+	echo "*** Project description file hasn't been set" >&2
+	exit 1
+	;;
+esac
+
+# --- Check types
+# if $newrev is 0000...0000, it's a commit to delete a ref.
+zero=$(git hash-object --stdin </dev/null | tr '[0-9a-f]' '0')
+if [ "$newrev" = "$zero" ]; then
+	newrev_type=delete
+else
+	newrev_type=$(git cat-file -t $newrev)
+fi
+
+case "$refname","$newrev_type" in
+	refs/tags/*,commit)
+		# un-annotated tag
+		short_refname=${refname##refs/tags/}
+		if [ "$allowunannotated" != "true" ]; then
+			echo "*** The un-annotated tag, $short_refname, is not allowed in this repository" >&2
+			echo "*** Use 'git tag [ -a | -s ]' for tags you want to propagate." >&2
+			exit 1
+		fi
+		;;
+	refs/tags/*,delete)
+		# delete tag
+		if [ "$allowdeletetag" != "true" ]; then
+			echo "*** Deleting a tag is not allowed in this repository" >&2
+			exit 1
+		fi
+		;;
+	refs/tags/*,tag)
+		# annotated tag
+		if [ "$allowmodifytag" != "true" ] && git rev-parse $refname > /dev/null 2>&1
+		then
+			echo "*** Tag '$refname' already exists." >&2
+			echo "*** Modifying a tag is not allowed in this repository." >&2
+			exit 1
+		fi
+		;;
+	refs/heads/*,commit)
+		# branch
+		if [ "$oldrev" = "$zero" -a "$denycreatebranch" = "true" ]; then
+			echo "*** Creating a branch is not allowed in this repository" >&2
+			exit 1
+		fi
+		;;
+	refs/heads/*,delete)
+		# delete branch
+		if [ "$allowdeletebranch" != "true" ]; then
+			echo "*** Deleting a branch is not allowed in this repository" >&2
+			exit 1
+		fi
+		;;
+	refs/remotes/*,commit)
+		# tracking branch
+		;;
+	refs/remotes/*,delete)
+		# delete tracking branch
+		if [ "$allowdeletebranch" != "true" ]; then
+			echo "*** Deleting a tracking branch is not allowed in this repository" >&2
+			exit 1
+		fi
+		;;
+	*)
+		# Anything else (is there anything else?)
+		echo "*** Update hook: unknown type of update to ref $refname of type $newrev_type" >&2
+		exit 1
+		;;
+esac
+
+# --- Finished
+exit 0

guam-0.9.11.tar.gz/_build/default/lib/syslog/.git/index Added

guam-0.9.11.tar.gz/_build/default/lib/syslog/.git/info Added

guam-0.9.11.tar.gz/_build/default/lib/syslog/.git/info/exclude Added

guam-0.9.11.tar.gz/_build/default/lib/syslog/.git/logs Added

guam-0.9.11.tar.gz/_build/default/lib/syslog/.git/logs/HEAD Added

guam-0.9.11.tar.gz/_build/default/lib/syslog/.git/logs/refs Added

guam-0.9.11.tar.gz/_build/default/lib/syslog/.git/logs/refs/heads Added

guam-0.9.11.tar.gz/_build/default/lib/syslog/.git/logs/refs/heads/master Added

guam-0.9.11.tar.gz/_build/default/lib/syslog/.git/logs/refs/remotes Added

guam-0.9.11.tar.gz/_build/default/lib/syslog/.git/logs/refs/remotes/origin Added

guam-0.9.11.tar.gz/_build/default/lib/syslog/.git/logs/refs/remotes/origin/HEAD Added

guam-0.9.11.tar.gz/_build/default/lib/syslog/.git/objects Added

guam-0.9.11.tar.gz/_build/default/lib/syslog/.git/objects/info Added

guam-0.9.11.tar.gz/_build/default/lib/syslog/.git/objects/pack Added

guam-0.9.11.tar.gz/_build/default/lib/syslog/.git/objects/pack/pack-530f2da589c2a7d368d96293bdcc65385e9d957a.idx Added

guam-0.9.11.tar.gz/_build/default/lib/syslog/.git/objects/pack/pack-530f2da589c2a7d368d96293bdcc65385e9d957a.pack Added

guam-0.9.11.tar.gz/_build/default/lib/syslog/.git/packed-refs Added

guam-0.9.11.tar.gz/_build/default/lib/syslog/.git/refs Added

guam-0.9.11.tar.gz/_build/default/lib/syslog/.git/refs/heads Added

guam-0.9.11.tar.gz/_build/default/lib/syslog/.git/refs/heads/master Added

guam-0.9.11.tar.gz/_build/default/lib/syslog/.git/refs/remotes Added

guam-0.9.11.tar.gz/_build/default/lib/syslog/.git/refs/remotes/origin Added

guam-0.9.11.tar.gz/_build/default/lib/syslog/.git/refs/remotes/origin/HEAD Added

guam-0.9.11.tar.gz/_build/default/lib/syslog/.git/refs/tags Added

guam-0.9.11.tar.gz/_build/default/lib/syslog/.git/refs/tags/0.0.1 Added

guam-0.9.11.tar.gz/_build/default/lib/syslog/.git/refs/tags/1.0.0 Added

guam-0.9.11.tar.gz/_build/default/lib/syslog/.git/refs/tags/1.0.1 Added

guam-0.9.11.tar.gz/_build/default/lib/syslog/.git/refs/tags/1.0.2 Added

guam-0.9.11.tar.gz/_build/default/lib/syslog/.git/refs/tags/1.0.3 Added

guam-0.9.11.tar.gz/_build/default/lib/syslog/.git/refs/tags/1.0.4 Added

guam-0.9.11.tar.gz/_build/default/lib/syslog/.git/refs/tags/1.0.5 Added

guam-0.9.11.tar.gz/_build/default/lib/syslog/.rebar3 Deleted

guam-0.9.11.tar.gz/_build/default/lib/syslog/.rebar3/rebar_compiler_erl Deleted

guam-0.9.11.tar.gz/_build/default/lib/syslog/.rebar3/rebar_compiler_erl/source.dag Deleted

guam-0.9.11.tar.gz/_build/default/lib/syslog/c_src/syslog_drv.d Deleted

guam-0.9.11.tar.gz/_build/default/lib/syslog/c_src/syslog_drv.o Deleted

guam-0.9.11.tar.gz/_build/default/lib/syslog/ebin Deleted

guam-0.9.11.tar.gz/_build/default/lib/syslog/ebin/syslog.app Deleted

guam-0.9.11.tar.gz/_build/default/lib/syslog/ebin/syslog.beam Deleted

guam-0.9.11.tar.gz/_build/default/lib/syslog/ebin/syslog_app.beam Deleted

guam-0.9.11.tar.gz/_build/default/lib/syslog/ebin/syslog_sup.beam Deleted

guam-0.9.11.tar.gz/_build/default/lib/syslog/priv Deleted

guam-0.9.11.tar.gz/_build/default/lib/syslog/priv/syslog_drv.so Deleted

guam-0.9.11.tar.gz/_build/default/plugins/pc/.rebar3/rebar_compiler_erl/source.dag Changed

guam-0.9.11.tar.gz/_checkouts Added

guam-0.9.11.tar.gz/_checkouts/eimap Added

guam-0.9.11.tar.gz/_checkouts/eimap/.arcconfig Added

guam-0.9.11.tar.gz/_checkouts/eimap/.erlang Added

guam-0.9.11.tar.gz/_checkouts/eimap/.git Added

guam-0.9.11.tar.gz/_checkouts/eimap/.git/HEAD Added

guam-0.9.11.tar.gz/_checkouts/eimap/.git/branches Added

guam-0.9.11.tar.gz/_checkouts/eimap/.git/config Added

guam-0.9.11.tar.gz/_checkouts/eimap/.git/description Added

guam-0.9.11.tar.gz/_checkouts/eimap/.git/hooks Added

guam-0.9.11.tar.gz/_checkouts/eimap/.git/hooks/applypatch-msg.sample Added

guam-0.9.11.tar.gz/_checkouts/eimap/.git/hooks/commit-msg.sample Added

guam-0.9.11.tar.gz/_checkouts/eimap/.git/hooks/fsmonitor-watchman.sample Added

@@ -0,0 +1,173 @@
+#!/usr/bin/perl
+
+use strict;
+use warnings;
+use IPC::Open2;
+
+# An example hook script to integrate Watchman
+# (https://facebook.github.io/watchman/) with git to speed up detecting
+# new and modified files.
+#
+# The hook is passed a version (currently 2) and last update token
+# formatted as a string and outputs to stdout a new update token and
+# all files that have been modified since the update token. Paths must
+# be relative to the root of the working tree and separated by a single NUL.
+#
+# To enable this hook, rename this file to "query-watchman" and set
+# 'git config core.fsmonitor .git/hooks/query-watchman'
+#
+my ($version, $last_update_token) = @ARGV;
+
+# Uncomment for debugging
+# print STDERR "$0 $version $last_update_token\n";
+
+# Check the hook interface version
+if ($version ne 2) {
+	die "Unsupported query-fsmonitor hook version '$version'.\n" .
+	 "Falling back to scanning...\n";
+}
+
+my $git_work_tree = get_working_dir();
+
+my $retry = 1;
+
+my $json_pkg;
+eval {
+	require JSON::XS;
+	$json_pkg = "JSON::XS";
+	1;
+} or do {
+	require JSON::PP;
+	$json_pkg = "JSON::PP";
+};
+
+launch_watchman();
+
+sub launch_watchman {
+	my $o = watchman_query();
+	if (is_work_tree_watched($o)) {
+		output_result($o->{clock}, @{$o->{files}});
+	}
+}
+
+sub output_result {
+	my ($clockid, @files) = @_;
+
+	# Uncomment for debugging watchman output
+	# open (my $fh, ">", ".git/watchman-output.out");
+	# binmode $fh, ":utf8";
+	# print $fh "$clockid\n@files\n";
+	# close $fh;
+
+	binmode STDOUT, ":utf8";
+	print $clockid;
+	print "\0";
+	local $, = "\0";
+	print @files;
+}
+
+sub watchman_clock {
+	my $response = qx/watchman clock "$git_work_tree"/;
+	die "Failed to get clock id on '$git_work_tree'.\n" .
+		"Falling back to scanning...\n" if $? != 0;
+
+	return $json_pkg->new->utf8->decode($response);
+}
+
+sub watchman_query {
+	my $pid = open2(\*CHLD_OUT, \*CHLD_IN, 'watchman -j --no-pretty')
+	or die "open2() failed: $!\n" .
+	"Falling back to scanning...\n";
+
+	# In the query expression below we're asking for names of files that
+	# changed since $last_update_token but not from the .git folder.
+	#
+	# To accomplish this, we're using the "since" generator to use the
+	# recency index to select candidate nodes and "fields" to limit the
+	# output to file names only. Then we're using the "expression" term to
+	# further constrain the results.
+	if (substr($last_update_token, 0, 1) eq "c") {
+		$last_update_token = "\"$last_update_token\"";
+	}
+	my $query = <<"	END";
+		["query", "$git_work_tree", {
+			"since": $last_update_token,
+			"fields": ["name"],
+			"expression": ["not", ["dirname", ".git"]]
+		}]
+	END
+
+	# Uncomment for debugging the watchman query
+	# open (my $fh, ">", ".git/watchman-query.json");
+	# print $fh $query;
+	# close $fh;
+
+	print CHLD_IN $query;
+	close CHLD_IN;
+	my $response = do {local $/; <CHLD_OUT>};
+
+	# Uncomment for debugging the watch response
+	# open ($fh, ">", ".git/watchman-response.json");
+	# print $fh $response;
+	# close $fh;
+
+	die "Watchman: command returned no output.\n" .
+	"Falling back to scanning...\n" if $response eq "";
+	die "Watchman: command returned invalid output: $response\n" .
+	"Falling back to scanning...\n" unless $response =~ /^\{/;
+
+	return $json_pkg->new->utf8->decode($response);
+}
+
+sub is_work_tree_watched {
+	my ($output) = @_;
+	my $error = $output->{error};
+	if ($retry > 0 and $error and $error =~ m/unable to resolve root .* directory (.*) is not watched/) {
+		$retry--;
+		my $response = qx/watchman watch "$git_work_tree"/;
+		die "Failed to make watchman watch '$git_work_tree'.\n" .
+		 "Falling back to scanning...\n" if $? != 0;
+		$output = $json_pkg->new->utf8->decode($response);
+		$error = $output->{error};
+		die "Watchman: $error.\n" .
+		"Falling back to scanning...\n" if $error;
+
+		# Uncomment for debugging watchman output
+		# open (my $fh, ">", ".git/watchman-output.out");
+		# close $fh;
+
+		# Watchman will always return all files on the first query so
+		# return the fast "everything is dirty" flag to git and do the
+		# Watchman query just to get it over with now so we won't pay
+		# the cost in git to look up each individual file.
+		my $o = watchman_clock();
+		$error = $output->{error};
+
+		die "Watchman: $error.\n" .
+		"Falling back to scanning...\n" if $error;
+
+		output_result($o->{clock}, ("/"));
+		$last_update_token = $o->{clock};
+
+		eval { launch_watchman() };
+		return 0;
+	}
+
+	die "Watchman: $error.\n" .
+	"Falling back to scanning...\n" if $error;
+
+	return 1;
+}
+
+sub get_working_dir {
+	my $working_dir;
+	if ($^O =~ 'msys' || $^O =~ 'cygwin') {
+		$working_dir = Win32::GetCwd();
+		$working_dir =~ tr/\\/\//;
+	} else {
+		require Cwd;
+		$working_dir = Cwd::cwd();
+	}
+
+	return $working_dir;
+}

guam-0.9.11.tar.gz/_checkouts/eimap/.git/hooks/post-update.sample Added

guam-0.9.11.tar.gz/_checkouts/eimap/.git/hooks/pre-applypatch.sample Added

guam-0.9.11.tar.gz/_checkouts/eimap/.git/hooks/pre-commit.sample Added

@@ -0,0 +1,49 @@
+#!/usr/bin/sh
+#
+# An example 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.
+#
+# To enable this hook, rename this file to "pre-commit".
+
+if git rev-parse --verify HEAD >/dev/null 2>&1
+then
+	against=HEAD
+else
+	# Initial commit: diff against an empty tree object
+	against=$(git hash-object -t tree /dev/null)
+fi
+
+# If you want to allow non-ASCII filenames set this variable to true.
+allownonascii=$(git config --type=bool hooks.allownonascii)
+
+# Redirect output to stderr.
+exec 1>&2
+
+# Cross platform projects tend to avoid non-ASCII filenames; prevent
+# them from being added to the repository. We exploit the fact that the
+# printable range starts at the space character and ends with tilde.
+if [ "$allownonascii" != "true" ] &&
+	# 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.
+	test $(git diff --cached --name-only --diff-filter=A -z $against |
+	 LC_ALL=C tr -d '[ -~]\0' | wc -c) != 0
+then
+	cat <<\EOF
+Error: Attempt to add a non-ASCII file name.
+
+This can cause problems if you want to work with people on other platforms.
+
+To be portable it is advisable to rename the file.
+
+If you know what you are doing you can disable this check using:
+
+ git config hooks.allownonascii true
+EOF
+	exit 1
+fi
+
+# If there are whitespace errors, print the offending file names and fail.
+exec git diff-index --check --cached $against --

guam-0.9.11.tar.gz/_checkouts/eimap/.git/hooks/pre-merge-commit.sample Added

guam-0.9.11.tar.gz/_checkouts/eimap/.git/hooks/pre-push.sample Added

@@ -0,0 +1,53 @@
+#!/usr/bin/sh
+
+# An example hook script to verify what is about to be pushed. Called by "git
+# push" after it has checked the remote status, but before anything has been
+# pushed. If this script exits with a non-zero status nothing will be pushed.
+#
+# This hook is called with the following parameters:
+#
+# $1 -- Name of the remote to which the push is being done
+# $2 -- URL to which the push is being done
+#
+# If pushing without using a named remote those arguments will be equal.
+#
+# Information about the commits which are being pushed is supplied as lines to
+# the standard input in the form:
+#
+# <local ref> <local oid> <remote ref> <remote oid>
+#
+# This sample shows how to prevent push of commits where the log message starts
+# with "WIP" (work in progress).
+
+remote="$1"
+url="$2"
+
+zero=$(git hash-object --stdin </dev/null | tr '[0-9a-f]' '0')
+
+while read local_ref local_oid remote_ref remote_oid
+do
+	if test "$local_oid" = "$zero"
+	then
+		# Handle delete
+		:
+	else
+		if test "$remote_oid" = "$zero"
+		then
+			# New branch, examine all commits
+			range="$local_oid"
+		else
+			# Update to existing branch, examine new commits
+			range="$remote_oid..$local_oid"
+		fi
+
+		# Check for WIP commit
+		commit=$(git rev-list -n 1 --grep '^WIP' "$range")
+		if test -n "$commit"
+		then
+			echo >&2 "Found WIP commit in $local_ref, not pushing"
+			exit 1
+		fi
+	fi
+done
+
+exit 0

guam-0.9.11.tar.gz/_checkouts/eimap/.git/hooks/pre-rebase.sample Added

@@ -0,0 +1,169 @@
+#!/usr/bin/sh
+#
+# Copyright (c) 2006, 2008 Junio C Hamano
+#
+# The "pre-rebase" hook is run just before "git rebase" starts doing
+# its job, and can prevent the command from running by exiting with
+# non-zero status.
+#
+# The hook is called with the following parameters:
+#
+# $1 -- the upstream the series was forked from.
+# $2 -- the branch being rebased (or empty when rebasing the current branch).
+#
+# This sample shows how to prevent topic branches that are already
+# merged to 'next' branch from getting rebased, because allowing it
+# would result in rebasing already published history.
+
+publish=next
+basebranch="$1"
+if test "$#" = 2
+then
+	topic="refs/heads/$2"
+else
+	topic=`git symbolic-ref HEAD` ||
+	exit 0 ;# we do not interrupt rebasing detached HEAD
+fi
+
+case "$topic" in
+refs/heads/??/*)
+	;;
+*)
+	exit 0 ;# we do not interrupt others.
+	;;
+esac
+
+# Now we are dealing with a topic branch being rebased
+# on top of master. Is it OK to rebase it?
+
+# Does the topic really exist?
+git show-ref -q "$topic" || {
+	echo >&2 "No such branch $topic"
+	exit 1
+}
+
+# Is topic fully merged to master?
+not_in_master=`git rev-list --pretty=oneline ^master "$topic"`
+if test -z "$not_in_master"
+then
+	echo >&2 "$topic is fully merged to master; better remove it."
+	exit 1 ;# we could allow it, but there is no point.
+fi
+
+# Is topic ever merged to next? If so you should not be rebasing it.
+only_next_1=`git rev-list ^master "^$topic" ${publish} | sort`
+only_next_2=`git rev-list ^master ${publish} | sort`
+if test "$only_next_1" = "$only_next_2"
+then
+	not_in_topic=`git rev-list "^$topic" master`
+	if test -z "$not_in_topic"
+	then
+		echo >&2 "$topic is already up to date with master"
+		exit 1 ;# we could allow it, but there is no point.
+	else
+		exit 0
+	fi
+else
+	not_in_next=`git rev-list --pretty=oneline ^${publish} "$topic"`
+	/usr/bin/perl -e '
+		my $topic = $ARGV[0];
+		my $msg = "* $topic has commits already merged to public branch:\n";
+		my (%not_in_next) = map {
+			/^([0-9a-f]+) /;
+			($1 => 1);
+		} split(/\n/, $ARGV[1]);
+		for my $elem (map {
+				/^([0-9a-f]+) (.*)$/;
+				[$1 => $2];
+			} split(/\n/, $ARGV[2])) {
+			if (!exists $not_in_next{$elem->[0]}) {
+				if ($msg) {
+					print STDERR $msg;
+					undef $msg;
+				}
+				print STDERR " $elem->[1]\n";
+			}
+		}
+	' "$topic" "$not_in_next" "$not_in_master"
+	exit 1
+fi
+
+<<\DOC_END
+
+This sample hook safeguards topic branches that have been
+published from being rewound.
+
+The workflow assumed here is:
+
+ * Once a topic branch forks from "master", "master" is never
+ merged into it again (either directly or indirectly).
+
+ * Once a topic branch is fully cooked and merged into "master",
+ it is deleted. If you need to build on top of it to correct
+ earlier mistakes, a new topic branch is created by forking at
+ the tip of the "master". This is not strictly necessary, but
+ it makes it easier to keep your history simple.
+
+ * Whenever you need to test or publish your changes to topic
+ branches, merge them into "next" branch.
+
+The script, being an example, hardcodes the publish branch name
+to be "next", but it is trivial to make it configurable via
+$GIT_DIR/config mechanism.
+
+With this workflow, you would want to know:
+
+(1) ... if a topic branch has ever been merged to "next". Young
+ topic branches can have stupid mistakes you would rather
+ clean up before publishing, and things that have not been
+ merged into other branches can be easily rebased without
+ affecting other people. But once it is published, you would
+ not want to rewind it.
+
+(2) ... if a topic branch has been fully merged to "master".
+ Then you can delete it. More importantly, you should not
+ build on top of it -- other people may already want to
+ change things related to the topic as patches against your
+ "master", so if you need further changes, it is better to
+ fork the topic (perhaps with the same name) afresh from the
+ tip of "master".
+
+Let's look at this example:
+
+		 o---o---o---o---o---o---o---o---o---o "next"
+		 / / / /
+		 / a---a---b A / /
+		/ / / /
+	 / / c---c---c---c B /
+	 / / / \ /
+	 / / / b---b C \ /
+	 / / / / \ /
+ ---o---o---o---o---o---o---o---o---o---o---o "master"
+
+
+A, B and C are topic branches.
+
+ * A has one fix since it was merged up to "next".
+
+ * B has finished. It has been fully merged up to "master" and "next",
+ and is ready to be deleted.
+
+ * C has not merged to "next" at all.
+
+We would want to allow C to be rebased, refuse A, and encourage
+B to be deleted.
+
+To compute (1):
+
+	git rev-list ^master ^topic next
+	git rev-list ^master next
+
+	if these match, topic has not merged in next at all.
+
+To compute (2):
+
+	git rev-list master..topic
+
+	if this is empty, it is fully merged to "master".
+
+DOC_END

guam-0.9.11.tar.gz/_checkouts/eimap/.git/hooks/pre-receive.sample Added

guam-0.9.11.tar.gz/_checkouts/eimap/.git/hooks/prepare-commit-msg.sample Added

@@ -0,0 +1,42 @@
+#!/usr/bin/sh
+#
+# An example hook script to prepare the commit log message.
+# Called by "git commit" with the name of the file that has the
+# commit message, followed by the description of the commit
+# message's source.  The hook's purpose is to edit the commit
+# message file.  If the hook fails with a non-zero status,
+# the commit is aborted.
+#
+# To enable this hook, rename this file to "prepare-commit-msg".
+
+# This hook includes three examples. The first one removes the
+# "# Please enter the commit message..." help message.
+#
+# The second includes the output of "git diff --name-status -r"
+# into the message, just before the "git status" output.  It is
+# commented because it doesn't cope with --amend or with squashed
+# commits.
+#
+# The third example adds a Signed-off-by line to the message, that can
+# still be edited.  This is rarely a good idea.
+
+COMMIT_MSG_FILE=$1
+COMMIT_SOURCE=$2
+SHA1=$3
+
+/usr/bin/perl -i.bak -ne 'print unless(m/^. Please enter the commit message/..m/^#$/)' "$COMMIT_MSG_FILE"
+
+# case "$COMMIT_SOURCE,$SHA1" in
+#  ,|template,)
+#    /usr/bin/perl -i.bak -pe '
+#       print "\n" . `git diff --cached --name-status -r`
+# 	 if /^#/ && $first++ == 0' "$COMMIT_MSG_FILE" ;;
+#  *) ;;
+# esac
+
+# SOB=$(git var GIT_COMMITTER_IDENT | sed -n 's/^$.*>$.*$/Signed-off-by: \1/p')
+# git interpret-trailers --in-place --trailer "$SOB" "$COMMIT_MSG_FILE"
+# if test -z "$COMMIT_SOURCE"
+# then
+#   /usr/bin/perl -i.bak -pe 'print "\n" if !$first_line++' "$COMMIT_MSG_FILE"
+# fi

guam-0.9.11.tar.gz/_checkouts/eimap/.git/hooks/push-to-checkout.sample Added

@@ -0,0 +1,78 @@
+#!/usr/bin/sh
+
+# An example hook script to update a checked-out tree on a git push.
+#
+# This hook is invoked by git-receive-pack(1) when it reacts to git
+# push and updates reference(s) in its repository, and when the push
+# tries to update the branch that is currently checked out and the
+# receive.denyCurrentBranch configuration variable is set to
+# updateInstead.
+#
+# By default, such a push is refused if the working tree and the index
+# of the remote repository has any difference from the currently
+# checked out commit; when both the working tree and the index match
+# the current commit, they are updated to match the newly pushed tip
+# of the branch. This hook is to be used to override the default
+# behaviour; however the code below reimplements the default behaviour
+# as a starting point for convenient modification.
+#
+# The hook receives the commit with which the tip of the current
+# branch is going to be updated:
+commit=$1
+
+# It can exit with a non-zero status to refuse the push (when it does
+# so, it must not modify the index or the working tree).
+die () {
+	echo >&2 "$*"
+	exit 1
+}
+
+# Or it can make any necessary changes to the working tree and to the
+# index to bring them to the desired state when the tip of the current
+# branch is updated to the new commit, and exit with a zero status.
+#
+# For example, the hook can simply run git read-tree -u -m HEAD "$1"
+# in order to emulate git fetch that is run in the reverse direction
+# with git push, as the two-tree form of git read-tree -u -m is
+# essentially the same as git switch or git checkout that switches
+# branches while keeping the local changes in the working tree that do
+# not interfere with the difference between the branches.
+
+# The below is a more-or-less exact translation to shell of the C code
+# for the default behaviour for git's push-to-checkout hook defined in
+# the push_to_deploy() function in builtin/receive-pack.c.
+#
+# Note that the hook will be executed from the repository directory,
+# not from the working tree, so if you want to perform operations on
+# the working tree, you will have to adapt your code accordingly, e.g.
+# by adding "cd .." or using relative paths.
+
+if ! git update-index -q --ignore-submodules --refresh
+then
+	die "Up-to-date check failed"
+fi
+
+if ! git diff-files --quiet --ignore-submodules --
+then
+	die "Working directory has unstaged changes"
+fi
+
+# This is a rough translation of:
+#
+# head_has_history() ? "HEAD" : EMPTY_TREE_SHA1_HEX
+if git cat-file -e HEAD 2>/dev/null
+then
+	head=HEAD
+else
+	head=$(git hash-object -t tree --stdin </dev/null)
+fi
+
+if ! git diff-index --quiet --cached --ignore-submodules $head --
+then
+	die "Working directory has staged changes"
+fi
+
+if ! git read-tree -u -m "$commit"
+then
+	die "Could not update working tree to new HEAD"
+fi

guam-0.9.11.tar.gz/_checkouts/eimap/.git/hooks/update.sample Added

@@ -0,0 +1,128 @@
+#!/usr/bin/sh
+#
+# An example hook script to block unannotated tags from entering.
+# Called by "git receive-pack" with arguments: refname sha1-old sha1-new
+#
+# To enable this hook, rename this file to "update".
+#
+# Config
+# ------
+# hooks.allowunannotated
+# This boolean sets whether unannotated tags will be allowed into the
+# repository. By default they won't be.
+# hooks.allowdeletetag
+# This boolean sets whether deleting tags will be allowed in the
+# repository. By default they won't be.
+# hooks.allowmodifytag
+# This boolean sets whether a tag may be modified after creation. By default
+# it won't be.
+# hooks.allowdeletebranch
+# This boolean sets whether deleting branches will be allowed in the
+# repository. By default they won't be.
+# hooks.denycreatebranch
+# This boolean sets whether remotely creating branches will be denied
+# in the repository. By default this is allowed.
+#
+
+# --- Command line
+refname="$1"
+oldrev="$2"
+newrev="$3"
+
+# --- Safety check
+if [ -z "$GIT_DIR" ]; then
+	echo "Don't run this script from the command line." >&2
+	echo " (if you want, you could supply GIT_DIR then run" >&2
+	echo " $0 <ref> <oldrev> <newrev>)" >&2
+	exit 1
+fi
+
+if [ -z "$refname" -o -z "$oldrev" -o -z "$newrev" ]; then
+	echo "usage: $0 <ref> <oldrev> <newrev>" >&2
+	exit 1
+fi
+
+# --- Config
+allowunannotated=$(git config --type=bool hooks.allowunannotated)
+allowdeletebranch=$(git config --type=bool hooks.allowdeletebranch)
+denycreatebranch=$(git config --type=bool hooks.denycreatebranch)
+allowdeletetag=$(git config --type=bool hooks.allowdeletetag)
+allowmodifytag=$(git config --type=bool hooks.allowmodifytag)
+
+# check for no description
+projectdesc=$(sed -e '1q' "$GIT_DIR/description")
+case "$projectdesc" in
+"Unnamed repository"* | "")
+	echo "*** Project description file hasn't been set" >&2
+	exit 1
+	;;
+esac
+
+# --- Check types
+# if $newrev is 0000...0000, it's a commit to delete a ref.
+zero=$(git hash-object --stdin </dev/null | tr '[0-9a-f]' '0')
+if [ "$newrev" = "$zero" ]; then
+	newrev_type=delete
+else
+	newrev_type=$(git cat-file -t $newrev)
+fi
+
+case "$refname","$newrev_type" in
+	refs/tags/*,commit)
+		# un-annotated tag
+		short_refname=${refname##refs/tags/}
+		if [ "$allowunannotated" != "true" ]; then
+			echo "*** The un-annotated tag, $short_refname, is not allowed in this repository" >&2
+			echo "*** Use 'git tag [ -a | -s ]' for tags you want to propagate." >&2
+			exit 1
+		fi
+		;;
+	refs/tags/*,delete)
+		# delete tag
+		if [ "$allowdeletetag" != "true" ]; then
+			echo "*** Deleting a tag is not allowed in this repository" >&2
+			exit 1
+		fi
+		;;
+	refs/tags/*,tag)
+		# annotated tag
+		if [ "$allowmodifytag" != "true" ] && git rev-parse $refname > /dev/null 2>&1
+		then
+			echo "*** Tag '$refname' already exists." >&2
+			echo "*** Modifying a tag is not allowed in this repository." >&2
+			exit 1
+		fi
+		;;
+	refs/heads/*,commit)
+		# branch
+		if [ "$oldrev" = "$zero" -a "$denycreatebranch" = "true" ]; then
+			echo "*** Creating a branch is not allowed in this repository" >&2
+			exit 1
+		fi
+		;;
+	refs/heads/*,delete)
+		# delete branch
+		if [ "$allowdeletebranch" != "true" ]; then
+			echo "*** Deleting a branch is not allowed in this repository" >&2
+			exit 1
+		fi
+		;;
+	refs/remotes/*,commit)
+		# tracking branch
+		;;
+	refs/remotes/*,delete)
+		# delete tracking branch
+		if [ "$allowdeletebranch" != "true" ]; then
+			echo "*** Deleting a tracking branch is not allowed in this repository" >&2
+			exit 1
+		fi
+		;;
+	*)
+		# Anything else (is there anything else?)
+		echo "*** Update hook: unknown type of update to ref $refname of type $newrev_type" >&2
+		exit 1
+		;;
+esac
+
+# --- Finished
+exit 0

guam-0.9.11.tar.gz/_checkouts/eimap/.git/index Added

guam-0.9.11.tar.gz/_checkouts/eimap/.git/info Added

guam-0.9.11.tar.gz/_checkouts/eimap/.git/info/exclude Added

guam-0.9.11.tar.gz/_checkouts/eimap/.git/logs Added

guam-0.9.11.tar.gz/_checkouts/eimap/.git/logs/HEAD Added

guam-0.9.11.tar.gz/_checkouts/eimap/.git/objects Added

guam-0.9.11.tar.gz/_checkouts/eimap/.git/objects/info Added

guam-0.9.11.tar.gz/_checkouts/eimap/.git/objects/pack Added

guam-0.9.11.tar.gz/_checkouts/eimap/.git/objects/pack/pack-c1b573ef1424aa74bc2580b50c5712c5af8505e9.idx Added

guam-0.9.11.tar.gz/_checkouts/eimap/.git/objects/pack/pack-c1b573ef1424aa74bc2580b50c5712c5af8505e9.pack Added

guam-0.9.11.tar.gz/_checkouts/eimap/.git/packed-refs Added

guam-0.9.11.tar.gz/_checkouts/eimap/.git/refs Added

guam-0.9.11.tar.gz/_checkouts/eimap/.git/refs/heads Added

guam-0.9.11.tar.gz/_checkouts/eimap/.git/refs/tags Added

guam-0.9.11.tar.gz/_checkouts/eimap/.git/refs/tags/0.1 Added

guam-0.9.11.tar.gz/_checkouts/eimap/.git/refs/tags/0.1.1 Added

guam-0.9.11.tar.gz/_checkouts/eimap/.git/refs/tags/0.1.2 Added

guam-0.9.11.tar.gz/_checkouts/eimap/.git/refs/tags/0.1.4 Added

guam-0.9.11.tar.gz/_checkouts/eimap/.git/refs/tags/0.2 Added

guam-0.9.11.tar.gz/_checkouts/eimap/.git/refs/tags/0.2.1 Added

guam-0.9.11.tar.gz/_checkouts/eimap/.git/refs/tags/0.2.2 Added

guam-0.9.11.tar.gz/_checkouts/eimap/.git/refs/tags/0.2.3 Added

guam-0.9.11.tar.gz/_checkouts/eimap/.git/refs/tags/0.2.4 Added

guam-0.9.11.tar.gz/_checkouts/eimap/.git/refs/tags/0.2.5 Added

guam-0.9.11.tar.gz/_checkouts/eimap/.git/refs/tags/0.3.0 Added

guam-0.9.11.tar.gz/_checkouts/eimap/.git/refs/tags/0.4.0 Added

guam-0.9.11.tar.gz/_checkouts/eimap/.git/refs/tags/0.4.1 Added

guam-0.9.11.tar.gz/_checkouts/eimap/.git/refs/tags/0.4.2 Added

guam-0.9.11.tar.gz/_checkouts/eimap/.git/refs/tags/0.4.3 Added

guam-0.9.11.tar.gz/_checkouts/eimap/.git/refs/tags/eimap-0.1.2 Added

guam-0.9.11.tar.gz/_checkouts/eimap/.git/refs/tags/eimap-0.1.5 Added

guam-0.9.11.tar.gz/_checkouts/eimap/.gitignore Added

guam-0.9.11.tar.gz/_checkouts/eimap/CHANGELOG.md Added

@@ -0,0 +1,70 @@
+# Changelog
+All notable changes to this project will be documented in this file.
+
+This project adheres to [Semantic Versioning](http://semver.org/).
+
+## [Unreleased]
+### Added
+### Changed
+### Deprecated
+### Removed
+### Fixed
+### Security
+
+## [0.4.4] - 2021-05-31
+### Fixed
+- LITERAL+ support
+
+## [0.4.3] - 2020-10-28
+### Fixed
+- Throttle reading of responses if the target process's inbox is getting full.
+
+## [0.4.2] - 2020-04-24
+### Fixed
+- Workaround for metadata request breaking other commands (required for guam)
+
+## [0.4.1] - 2020-03-28
+### Added
+- Enabled tcp keepalive
+- Support for untagged commands
+
+## [0.4.0] - 2016-11-11
+### Added
+- optional timeout on eimap objects for server delay
+  passing in an integer command_timeout value to eimap:start_link
+  sets the timeout to that number of ms
+
+### Fixed
+- METADATA command parses multiple key/value returns correctly
+
+## [0.3.0] - 2016-07-29
+### Changed
+- moved to rebar3
+
+### Fixed
+- consistency in capabilities response parsing
+
+## [0.2.5] - 2016-07-04
+### Fixed
+- improved the capabilities response parsing
+
+## [0.2.4] - 2016-06-08
+This section contains the changes from 0.2.0 through 0.2.4
+### Added
+- NOOP command
+- support for automated interruption of passthrough state to send structured commands
+- commands receive server responses for commands they put into the queue
+
+### Changed
+- centralize core IMAP response handling and utils in eimap_command
+- support for multi-line, single-line and binary response command types
+- improved TLS support
+
+### Fixed
+- crash in GETMETADATA command when the Folder param is a list
+- Support more variations of the LIST command args in the filter_groupware rule
+- Prevent crashes (while maintaining simplicity) in session FSM by limiting
+  processcommandqueue messages in the mailbox to one
+- support for literals continuation
+- fixes for metadata fetching
+

guam-0.9.11.tar.gz/_checkouts/eimap/LICENSE Added

guam-0.9.11.tar.gz/_checkouts/eimap/Makefile Added

guam-0.9.11.tar.gz/_checkouts/eimap/README.md Added

@@ -0,0 +1,202 @@
+This is a basic IMAP client implementation written in Erlang.
+
+The API is not finalized, and is currently limited to the eimap module. Its
+current and only recognized use case is software intended to interact with a
+Kolab server environment which are written in Erlang. Expansion of that scope
+is welcome through community participation. However, currently the following
+disclaimer should be taken with seriousness:
+
+ USE AT YOUR OWN RISK. THINGS WILL CHANGE.
+
+The following is equally true, however:
+
+ CONTRIBUTIONS WELCOME. USAGE WELCOME.
+
+Usage
+=====
+
+To add eimap from your application, add the following line to the deps of rebar.config:
+
+ * rebar 2.x: { eimap, "*", {git, "git://git.kolab.org/diffusion/EI/eimap.git" } }
+ * rebar3: eimap
+
+
+
+There is no need to start the eimap application as it does not have any process
+or startup routines related to its usage. eimap does rely on lager being avilable,
+however.
+
+eimap Module
+============
+The eimap erlang module is the home of the primary API for the eimap library. It
+is a gen_fsm and should be started as a process in the normal Erlang/OTP manner for
+use.
+
+An eimap instance represents a single IMAP connection to a single IMAP server
+and is stateful: commands that are started may change the selected folder, for
+instance, and commands that are sent may be put into a command queue for subsequent
+execution depeding on the current state of the connection.
+
+Once started, an eimap process may be directed to connect to an imap server
+and then start with functions such as fetching path tokens:
+
+ ImapServerArgs = [ { host, "imap.acme.com" }, { port, 143 }, { tls, starttls } ]
+ { ok, Imap } = eimap:start_link(ImapServerArgs),
+ eimap_imap:starttls(),
+ eimap_imap:login(Imap, self(), undefined, "username", "password"),
+ eimap_imap:connect(Imap),
+ eimap_imap:get_path_tokens(Imap, self(), get_path_tokens)
+
+The Imap server args is a simple proplist which allows one to set
+host, port and TLS settings. For TLS, the following values are supported:
+
+ * true: start a TLS session when opening the socket ("implicit TLS")
+ * starttls: start TLS via the STARTTLS IMAP command auomagically
+ * false: just open a regular connection; this is what you usually want, and
+ the client will call eimap:starttls/3 when it wishes to switch to
+ an encrypted connection
+
+The starttls, login and even get_path_tokens commands will be
+queued and sent to the IMAP server only when the connection has been established.
+This prevents having to wait for connection signals and lets you write what you
+intend to be executed with as few issues as possible.
+
+Commands are executed in the order they are queued, and they follow a consistent
+parametic pattern:
+
+ * the first parameter is the eimap PID returned by eimap:start_link/1
+ * the second parameter is the PID the response should be sent to as a message
+ * the third parameter is a token to send back with the response, allowing users
+ of eimap to track responses to specific commands; undefined is allowed and will
+ surpress the use of a response token
+ * .. additional parameters specific to the command, such as username and
+ password in the case of login
+
+Responses are sent as a normal message with the form:
+
+ Response
+ { Token, Resposne }
+
+The Token is the resposne token provided as the third parameter and may be anything.
+The Response depends on the given command, but will be a properly formed Erlang term
+representing the content of the response.
+
+Passthrough Mode
+================
+eimap supports a mode of operation which simply passes data between the user
+and the imap server blindly. This is known as "passthrough" mode and can be
+started and stopped with the start_passthrough/2 and stop_passthrough/1
+functions.
+
+Data is queued up for sending with the passthrough_data/2 function, and will be
+sent to the server as soon as possible.
+
+Responses are similarly sent back to the initiator of the passthrough mode
+for dispatch in the form of { imap_server_response, Data } messages. The receiver
+is the PID passed to start_passthrough/2 as the second parameter.
+
+As the user is entirely responsible for the traffic and thereby the state
+of the IMAP conenction during passthrough, exercise caution while using
+this mode.
+
+Any commands which are queued using eimap's command functions (logini/5,
+logout/3, etc) will interupt passthrough to run those commands. Once the queued
+commands have been cleared passthrough will restart auomatically.
+
+Commands
+========
+
+Individual commands are implemented in individual modules in the src/commands/
+directory, and this is the prefered mechanism for adding features to eimap.
+
+The API for commands is defined in src/eimap_command.erl as a behavior. Commands
+are expected to provide at least two functions:
+
+ new_command(Args) -> { Command, ResponseType }
+ create a command bitstring to be passed to the imap server and defines
+ the type of response for this command. Response types include
+ single_line_response, multiline_response, all_multiline_response
+ and blob_response.
+
+ Args is specific to the command, and some commands
+ ignore this parameter
+
+Single line response
+--------------------
+Commands which the IMAP server will respond to with a single line in return
+should use single_line_response and must implement formulate_response/2 which
+is passed the Data and the command Tag. This usually returns one of
+{ fini, Result } or { error, Reason }, though some special commands may return
+atoms which the eimap module responds to such as starttls.
+
+Multiline Response
+------------------
+This is the most common response type and is used when the IMAP server may
+respond with zero or more untagged responses and a final tagged response.
+
+Such commands must implement:
+
+ process_line/2 which is passed one line at a time (minus newlines)
+ and a list accumulator to add responses to
+
+ formulate_response/2 which is passed ok on success or an error tuple of 
+ { [no|bad], Reason }. This should return either { fini, Response } or
+ { error, Reason } in most cases; and for that there is
+ eimap_command:formulate_response. Which means that for most commands
+ formulate_response/2 is implemented as:
+
+ formulate_response(Result, Response) -> eimap_command:formulate(Result, Response).
+
+Commands which are all_multiline_responses also must implement process_tagged_line/2
+which behaves exactly like process_line but which accepts the tagged response line
+from the IMAP server. This is useful for commands where useful information is also
+passed in the tagged response line. An example of this is the select/exmine
+commands.
+
+Unstructured (blob) responses
+-----------------------------
+Responses that do not follow the usual untagged/tagged line response pattern
+may use the blog_response type and implement parse/2 which will be passed
+the data as it arrives. The command is responsible for all buffer stitching
+across network packets, etc.
+
+In the case of partial responses, parse/2 may return { more, fun/3, State }.
+The State object allows preserving the parsing state and will be passed back to
+fun/3 in addition to the Data and Tag parameters.
+
+parse/2 (or the continuation fun/3) should return { fini, Result } when 
+successfully completed, or { error, Reason } when it fails. Only once either a
+fini or error tuple are returned will the eimap process move on to the next
+command queued.
+
+IMAP Utils
+==========
+
+eimap_utils provides a set of handy helpers for use when IMAP'ing your way
+across the network. These include folder path and UID set extractors, IMAP
+server response manipulators and misc utilities.
+
+Testing
+=======
+Tests can be run with `make tests` or `rebar eunit`.
+
+All new commands must be accompanied by tests in the test/ directory.
+
+Contributing
+============
+Maintainer: Aaron Seigo <aseigo@kolabsystems.com>
+Mailing list: devel@lists.kolab.com
+Project page: https://git.kolab.org/tag/eimap/
+
+This project uses the git flow workflow as described here:
+
+ http://nvie.com/posts/a-successful-git-branching-model/
+
+You can installed git flow from here:
+
+ https://github.com/nvie/gitflow
+
+Then initialize your local clone with `git flow init -d`.
+
+You can find the list of open tasks on the project page's workboard. Anything
+in the backlog is open to be worked on.

guam-0.9.11.tar.gz/_checkouts/eimap/rebar.config Added

guam-0.9.11.tar.gz/_checkouts/eimap/rebar3 Added

guam-0.9.11.tar.gz/_checkouts/eimap/src Added

guam-0.9.11.tar.gz/_checkouts/eimap/src/commands Added

guam-0.9.11.tar.gz/_checkouts/eimap/src/commands/eimap_command_annotation.erl Added

@@ -0,0 +1,49 @@
+%% Copyright 2014 Kolab Systems AG (http://www.kolabsys.com)
+%%
+%% Aaron Seigo (Kolab Systems) <seigo a kolabsys.com>
+%%
+%% This program is free software: you can redistribute it and/or modify
+%% it under the terms of the GNU Library 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 Library General Public License for more details.
+%%
+%% You should have received a copy of the GNU Library General Public License
+%% along with this program. If not, see <http://www.gnu.org/licenses/>.
+
+-module(eimap_command_annotation).
+-behavior(eimap_command).
+-export([new_command/1, process_line/2, formulate_response/2]).
+
+%% Public API
+new_command(Folder) when is_list(Folder) -> new_command(list_to_binary(Folder));
+new_command(Folder) -> { <<"GETANNOTATION \"", Folder/binary, "\" \"*\" \"value.shared\"">>, multiline_response }.
+
+process_line(<<" ", Data/binary>>, Acc) ->
+ process_line(Data, Acc);
+process_line(<<"* ANNOTATION ", Data/binary>>, Acc) ->
+ Pieces = binary:split(Data, <<"\"">>, [global]),
+ process_pieces(Pieces, Acc);
+process_line(<<>>, Acc) ->
+ Acc.
+
+formulate_response(Result, Data) -> eimap_command:formulate_response(Result, Data).
+
+%% Private API
+process_pieces([MBox, Key, _, _, _, Value, _], Acc) when MBox =/= <<>> -> [ { Key, translate(Value) } | Acc ];
+process_pieces([_, _MBox, _, Key, _, _, _, Value, _], Acc) -> [ { Key, translate(Value) } | Acc ];
+process_pieces(_, Acc) -> Acc.
+
+translate(<<"false">>) -> false;
+translate(<<"true">>) -> true;
+translate(Value) ->
+ try list_to_integer(binary_to_list(Value)) of
+ Number -> Number
+ catch
+ _:_ -> Value
+ end.
+

guam-0.9.11.tar.gz/_checkouts/eimap/src/commands/eimap_command_capability.erl Added

@@ -0,0 +1,50 @@
+%% Copyright 2015 Kolab Systems AG (http://www.kolabsys.com)
+%%
+%% Aaron Seigo (Kolab Systems) <seigo a kolabsys.com>
+%%
+%% This program is free software: you can redistribute it and/or modify
+%% it under the terms of the GNU Library 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 Library General Public License for more details.
+%%
+%% You should have received a copy of the GNU Library General Public License
+%% along with this program. If not, see <http://www.gnu.org/licenses/>.
+
+-module(eimap_command_capability).
+-behavior(eimap_command).
+-export([new_command/1, process_line/2, formulate_response/2]).
+
+%% http://tools.ietf.org/html/rfc2342
+
+%% Public API
+new_command(parse_serverid) -> { <<"CAPABILITY">>, single_line_response };
+new_command(_Args) -> { <<"CAPABILITY">>, multiline_response }.
+
+process_line(<<"* CAPABILITY ", Data/binary>>, _Acc) ->
+ [Data];
+process_line(_Data, Acc) -> Acc.
+
+formulate_response(ok, Response) -> { fini, Response };
+formulate_response({ _, Reason }, _Data) -> { error, Reason };
+formulate_response(Data, Tag) -> parse_oneliner(eimap_utils:check_response_for_failure(Data, Tag),
+ eimap_utils:remove_tag_from_response(Data, Tag, check)).
+
+%% Private API
+% TODO: probably way too cyrus imap specific on the responses (capitalization, etc)
+% make generic with a nicer parser
+parse_oneliner(ok, <<"* OK [CAPABILITY ", Data/binary>>) ->
+ % this is a server response on connect
+ { End, _ } = binary:match(Data, <<"]">>),
+ { TextEnd, _ } = binary:match(Data, <<"\r\n">>),
+ Capabilities = binary:part(Data, { 0, End }),
+ ServerID = binary:part(Data, { End + 2, TextEnd - End - 2}),
+ { fini, { Capabilities, ServerID } };
+parse_oneliner({ _, Reason }, _Data) -> { error, Reason };
+parse_oneliner(_, Data) -> { fini, { Data, <<>> } }.
+
+

guam-0.9.11.tar.gz/_checkouts/eimap/src/commands/eimap_command_compress.erl Added

@@ -0,0 +1,32 @@
+%% Copyright 2014 Kolab Systems AG (http://www.kolabsys.com)
+%%
+%% Aaron Seigo (Kolab Systems) <seigo a kolabsys.com>
+%%
+%% This program is free software: you can redistribute it and/or modify
+%% it under the terms of the GNU Library 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 Library General Public License for more details.
+%%
+%% You should have received a copy of the GNU Library General Public License
+%% along with this program. If not, see <http://www.gnu.org/licenses/>.
+
+-module(eimap_command_compress).
+-behavior(eimap_command).
+-export([new_command/1, formulate_response/2]).
+
+%% http://tools.ietf.org/html/rfc2342
+
+%% Public API
+new_command(_Args) -> { <<"COMPRESS DEFLATE">>, single_line_response }.
+
+formulate_response(Data, Tag) ->
+ case eimap_utils:check_response_for_failure(Data, Tag) of
+ ok -> compression_active;
+ { _, Reason } -> { error, Reason }
+ end.
+

guam-0.9.11.tar.gz/_checkouts/eimap/src/commands/eimap_command_getmetadata.erl Added

@@ -0,0 +1,118 @@
+%% Copyright 2014 Kolab Systems AG (http://www.kolabsys.com)
+%%
+%% Aaron Seigo (Kolab Systems) <seigo a kolabsys.com>
+%%
+%% This program is free software: you can redistribute it and/or modify
+%% it under the terms of the GNU Library 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 Library General Public License for more details.
+%%
+%% You should have received a copy of the GNU Library General Public License
+%% along with this program. If not, see <http://www.gnu.org/licenses/>.
+
+-module(eimap_command_getmetadata).
+-behavior(eimap_command).
+-export([new_command/1, process_line/2, formulate_response/2]).
+
+%% http://tools.ietf.org/html/rfc2342
+
+%% Public API
+new_command({ Folder }) -> new_command({ Folder, [] });
+new_command({ Folder, Attributes }) -> new_command({ Folder, Attributes, infinity, nomax });
+
+%% Depth and MaxSize are both optional arguments, so we have a 4-tuple version of new_command to accomodate this
+%% "Depth, Maxsize" could be replaced with a proplist of the form [ { depth, Depth }, { maxsize, MaxSize } ] but
+%% as this is an internal (to eimap) API there is little benefit for the performance cost
+new_command({ Folder, Attributes, Depth, MaxSize }) when is_list(Folder) -> new_command({ list_to_binary(Folder), Attributes, Depth, MaxSize });
+new_command({ Folder, Attributes, Depth, MaxSize }) ->
+ AttributesString = format_attributes(Attributes, <<>>),
+ DepthString = depth_param(Depth),
+ MaxSizeString = maxsize_param(MaxSize),
+ Command = metadata_command(DepthString, MaxSizeString, Folder, AttributesString),
+ { Command, multiline_response }.
+
+process_line(<<"* METADATA ", Details/binary>>, Acc) ->
+ Results = parse_folder(Details),
+ [Results|Acc];
+process_line(_Line, Acc) -> Acc.
+
+formulate_response(Result, Data) -> eimap_command:formulate_response(Result, Data).
+
+%% Private API
+depth_param(infinity) -> <<"DEPTH infinity">>;
+depth_param(Depth) when is_integer(Depth) -> Bin = integer_to_binary(Depth), <<"DEPTH ", Bin/binary>>;
+depth_param(_) -> <<>>.
+
+maxsize_param(Size) when is_integer(Size) -> Bin = integer_to_binary(Size), <<"MAXSIZE ", Bin/binary>>;
+maxsize_param(_) -> <<>>.
+
+metadata_command(<<>>, <<>>, Folder, Attributes) -> <<"GETMETADATA \"", Folder/binary, "\"", Attributes/binary>>;
+metadata_command(Depth, <<>>, Folder, Attributes) -> <<"GETMETADATA (", Depth/binary, ") \"", Folder/binary, "\"", Attributes/binary>>;
+metadata_command(<<>>, MaxSize, Folder, Attributes) -> <<"GETMETADATA (", MaxSize/binary, ") \"", Folder/binary, "\"", Attributes/binary>>;
+metadata_command(Depth, MaxSize, Folder, Attributes) -> <<"GETMETADATA (", Depth/binary, " ", MaxSize/binary, ") \"", Folder/binary, "\"", Attributes/binary>>.
+
+format_attributes([], <<>>) -> <<>>;
+format_attributes([], String) -> <<" (", String/binary, ")">>;
+format_attributes([Attribute|Attributes], String) ->
+ AttrBin = case is_list(Attribute) of
+ true -> list_to_binary(Attribute);
+ false -> Attribute
+ end,
+ case String of
+ <<>> -> format_attributes(Attributes, AttrBin);
+ _ -> format_attributes(Attributes, <<String/binary, " ", AttrBin/binary>>)
+ end;
+format_attributes(_, _String) -> <<>>.
+
+parse_folder(<<"\"", Rest/binary>>) ->
+ { Folder, RemainingBuffer } = until_closing_quote(Rest),
+ Properties = parse_properties(RemainingBuffer),
+ { Folder, Properties };
+parse_folder(Buffer) ->
+ { FolderEnd, _ } = binary:match(Buffer, <<" ">>),
+ Folder = binary:part(Buffer, 0, FolderEnd),
+ Properties = parse_properties(binary:part(Buffer, FolderEnd, size(Buffer) - FolderEnd)),
+ { Folder, Properties }.
+
+parse_properties(Buffer) ->
+ { Start, _ } = binary:match(Buffer, <<"(">>),
+ { End, _ } = binary:match(Buffer, <<")">>),
+ Properties = binary:part(Buffer, Start + 1, End - Start - 1),
+ next_property(Properties, []).
+
+next_property(<<>>, Acc) -> Acc;
+next_property(<<$ ,Rest/binary>>, Acc) -> next_property(Rest, Acc);
+next_property(Buffer, Acc) ->
+ { KeyEnd, _ } = binary:match(Buffer, <<" ">>),
+ Key = binary:part(Buffer, 0, KeyEnd),
+ { Value, RemainingBuffer } = 
+ case next_value(binary:part(Buffer, KeyEnd + 1, size(Buffer) - KeyEnd - 1)) of
+ { <<"NIL">>, RBuffer } -> { null, RBuffer };
+ Rv -> Rv
+ end,
+ next_property(RemainingBuffer, [{ Key, Value }|Acc]).
+
+next_value(<<"\"", Rest/binary>>) ->
+ until_closing_quote(Rest);
+next_value(Buffer) ->
+ case binary:match(Buffer, <<" ">>) of
+ nomatch -> { Buffer, <<>> };
+ { ValueEnd , _ } -> { binary:part(Buffer, 0, ValueEnd - 1), binary:part(Buffer, ValueEnd, size(Buffer) - ValueEnd) }
+ end.
+
+until_closing_quote(Buffer) -> until_closing_quote(Buffer, 0, binary:at(Buffer, 0), 0, <<>>).
+
+until_closing_quote(Buffer, Start, $\\, Pos, Acc) ->
+ Escaped = binary:at(Buffer, Pos + 1 ),
+ until_closing_quote(Buffer, Start, binary:at(Buffer, Pos + 2), Pos + 2, <<Acc/binary, Escaped>>);
+until_closing_quote(Buffer, Start, $", Pos, Acc) ->
+ { Acc, binary:part(Buffer, Start + Pos + 1, size(Buffer) - Start - Pos - 1) };
+until_closing_quote(Buffer, _Start, Char, Pos, Acc) when Pos =:= size(Buffer) - 1 ->
+ { <<Acc/binary, Char>>, <<>> };
+until_closing_quote(Buffer, Start, Char, Pos, Acc) ->
+ until_closing_quote(Buffer, Start, binary:at(Buffer, Pos + 1), Pos + 1, <<Acc/binary, Char>>).

guam-0.9.11.tar.gz/_checkouts/eimap/src/commands/eimap_command_login.erl Added

@@ -0,0 +1,35 @@
+%% Copyright 2014 Kolab Systems AG (http://www.kolabsys.com)
+%%
+%% Aaron Seigo (Kolab Systems) <seigo a kolabsys.com>
+%%
+%% This program is free software: you can redistribute it and/or modify
+%% it under the terms of the GNU Library 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 Library General Public License for more details.
+%%
+%% You should have received a copy of the GNU Library General Public License
+%% along with this program. If not, see <http://www.gnu.org/licenses/>.
+
+-module(eimap_command_login).
+-behavior(eimap_command).
+-export([new_command/1, process_line/2, formulate_response/2]).
+
+%% http://tools.ietf.org/html/rfc2342
+
+%% Public API
+new_command({ User, Password }) ->
+ UserBin = eimap_utils:ensure_binary(User),
+ PasswordBin = eimap_utils:ensure_binary(Password),
+ { <<"LOGIN ", UserBin/binary, " ", PasswordBin/binary>>, multiline_response }.
+
+process_line(_Data, Acc) -> Acc.
+
+%% Private API
+formulate_response(ok, _Acc) -> { fini, authed };
+formulate_response({ _, Reason }, _Acc) -> { error, Reason }.
+

guam-0.9.11.tar.gz/_checkouts/eimap/src/commands/eimap_command_logout.erl Added

@@ -0,0 +1,29 @@
+%% Copyright 2014 Kolab Systems AG (http://www.kolabsys.com)
+%%
+%% Aaron Seigo (Kolab Systems) <seigo a kolabsys.com>
+%%
+%% This program is free software: you can redistribute it and/or modify
+%% it under the terms of the GNU Library 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 Library General Public License for more details.
+%%
+%% You should have received a copy of the GNU Library General Public License
+%% along with this program. If not, see <http://www.gnu.org/licenses/>.
+
+-module(eimap_command_logout).
+-behavior(eimap_command).
+-export([new_command/1, process_line/2, formulate_response/2]).
+
+%% Public API
+new_command(_Args) -> { <<"LOGOUT">>, multiline_response }.
+
+process_line(_Data, Acc) -> Acc.
+
+formulate_response(ok, _Data) -> { close_socket, ok };
+formulate_response({ _, Reason }, _Data) -> { close_socket, { error, Reason } }.
+

guam-0.9.11.tar.gz/_checkouts/eimap/src/commands/eimap_command_namespace.erl Added

@@ -0,0 +1,74 @@
+%% Copyright 2014 Kolab Systems AG (http://www.kolabsys.com)
+%%
+%% Aaron Seigo (Kolab Systems) <seigo a kolabsys.com>
+%%
+%% This program is free software: you can redistribute it and/or modify
+%% it under the terms of the GNU Library 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 Library General Public License for more details.
+%%
+%% You should have received a copy of the GNU Library General Public License
+%% along with this program. If not, see <http://www.gnu.org/licenses/>.
+
+-module(eimap_command_namespace).
+-behavior(eimap_command).
+-export([new_command/1, process_line/2, formulate_response/2]).
+
+%% http://tools.ietf.org/html/rfc2342
+
+%% Public API
+new_command(_Args) -> { <<"NAMESPACE">>, multiline_response }.
+
+process_line(<<"* NAMESPACE ", Data/binary>>, Acc) -> [process_shared_prefix_parts(Data, 1)|Acc];
+process_line(_Line, Acc) -> Acc.
+
+
+formulate_response(ok, [Acc]) -> { fini, relevant_shared_prefix_parts(Acc) };
+formulate_response({ _, Reason }, _Acc) -> { error, Reason }.
+
+% Private API
+relevant_shared_prefix_parts([]) -> { none, none};
+relevant_shared_prefix_parts([[], [], _]) -> { none, none };
+relevant_shared_prefix_parts([[], Delim]) -> { none, Delim };
+relevant_shared_prefix_parts([SharedPrefix, [], _]) -> { SharedPrefix, "/" };
+relevant_shared_prefix_parts([SharedPrefix, Delim]) -> { SharedPrefix, Delim }.
+
+process_shared_prefix_parts(<<"NIL ", Data/binary>>, PartNumber) ->
+ process_shared_prefix_parts(Data, PartNumber + 1);
+process_shared_prefix_parts(<<"NIL", Data/binary>>, PartNumber) ->
+ process_shared_prefix_parts(Data, PartNumber + 1);
+process_shared_prefix_parts(<<"((", Data/binary>>, PartNumber) ->
+ process_shared_prefix_parts_inner(Data, [], PartNumber);
+process_shared_prefix_parts(<<>>, _PartNumber) -> [].
+
+process_shared_prefix_parts_inner(<<"))", _/binary>>, Acc, 3) ->
+ parse_shared_prefix_fields(lists:reverse(Acc), []);
+process_shared_prefix_parts_inner(<<")) ", Data/binary>>, _Acc, N) ->
+ process_shared_prefix_parts(Data, N + 1);
+process_shared_prefix_parts_inner(<<Char, Data/binary>>, Acc, 3) ->
+ process_shared_prefix_parts_inner(Data, [Char|Acc], 3);
+process_shared_prefix_parts_inner(<<_Char, Data/binary>>, Acc, N) ->
+ process_shared_prefix_parts_inner(Data, Acc, N);
+process_shared_prefix_parts_inner(<<>>, _Acc, _N) ->
+ [].
+
+%%FIXME: naively assumes no "s in the values are allowed. is this correct?
+parse_shared_prefix_fields([$"|Tail], Acc) ->
+ parse_shared_prefix_field_inner(Tail, [], Acc);
+parse_shared_prefix_fields([_|Tail], Acc) ->
+ parse_shared_prefix_fields(Tail, Acc);
+parse_shared_prefix_fields([], Acc) ->
+ lists:reverse(Acc).
+
+parse_shared_prefix_field_inner([$"|Tail], PartAcc, Acc) ->
+ parse_shared_prefix_fields(Tail, [lists:reverse(PartAcc)|Acc]);
+parse_shared_prefix_field_inner([Char|Tail], PartAcc, Acc) ->
+ parse_shared_prefix_field_inner(Tail, [Char|PartAcc], Acc);
+parse_shared_prefix_field_inner([], _PartAcc, Acc) ->
+ Acc.
+

guam-0.9.11.tar.gz/_checkouts/eimap/src/commands/eimap_command_noop.erl Added

@@ -0,0 +1,30 @@
+%% Copyright 2014 Kolab Systems AG (http://www.kolabsys.com)
+%%
+%% Aaron Seigo (Kolab Systems) <seigo a kolabsys.com>
+%%
+%% This program is free software: you can redistribute it and/or modify
+%% it under the terms of the GNU Library 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 Library General Public License for more details.
+%%
+%% You should have received a copy of the GNU Library General Public License
+%% along with this program. If not, see <http://www.gnu.org/licenses/>.
+
+-module(eimap_command_noop).
+-behavior(eimap_command).
+-export([new_command/1, process_line/2, formulate_response/2]).
+
+%% https://tools.ietf.org/html/rfc3501#section-6.3.2
+
+%% Public API
+new_command(_) -> { <<"NOOP">>, multiline_response }.
+
+process_line(Data, Acc) -> eimap_command:process_status_line(Data, Acc).
+
+formulate_response(Response, Acc) -> eimap_command:formulate_response(Response, Acc).
+

guam-0.9.11.tar.gz/_checkouts/eimap/src/commands/eimap_command_peek_message.erl Added

@@ -0,0 +1,137 @@
+%% Copyright 2014 Kolab Systems AG (http://www.kolabsys.com)
+%%
+%% Aaron Seigo (Kolab Systems) <seigo a kolabsys.com>
+%%
+%% This program is free software: you can redistribute it and/or modify
+%% it under the terms of the GNU Library 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 Library General Public License for more details.
+%%
+%% You should have received a copy of the GNU Library General Public License
+%% along with this program. If not, see <http://www.gnu.org/licenses/>.
+
+-module(eimap_command_peek_message).
+-behavior(eimap_command).
+-export([new_command/1, parse/2, continue_parse/3]).
+-record(parse_state, { body_size, parts, data }).
+-record(parts, { headers = <<"">>, body = <<"">>, flags = <<"">> }).
+
+%% https://tools.ietf.org/html/rfc3501#section-6.4.5
+
+%% Public API
+new_command(MessageID) when is_integer(MessageID) -> new_command(integer_to_binary(MessageID));
+new_command(MessageID) when is_binary(MessageID) -> { <<"UID FETCH ", MessageID/binary, " (FLAGS BODY.PEEK[HEADER] BODY.PEEK[TEXT])">>, blob_response }.
+
+continue_parse(Data, _Tag, #parse_state{ body_size = Size, parts = Parts, data = PrevData }) ->
+ try_body_parse(<<PrevData/binary, Data/binary>>, Size, Parts).
+
+parse(Data, Tag) when is_binary(Data) ->
+ case eimap_utils:check_response_for_failure(Data, Tag) of
+ ok -> process_parts(get_past_headers(Data));
+ { _, Reason } -> { error, Reason }
+ end.
+
+%% Private API
+process_parts(#parts{ headers = Headers, flags = Flags, body = Body }) ->
+ { fini, [ { flags, binary:split(Flags, <<" ">>, [global]) },
+ { headers, filter_headers(binary:split(Headers, <<"\r\n">>, [global])) },
+ { message, <<Headers/binary, Body/binary>> } ] };
+process_parts(Result) ->
+ Result.
+
+get_past_headers(<<" OK ", _Data/binary>>) -> #parts{};
+get_past_headers(<<" FETCH ", Data/binary>>) -> find_open_parens(Data);
+get_past_headers(<<_, Data/binary>>) -> get_past_headers(Data);
+get_past_headers(<<>>) -> { error, <<"Unparsable">> }.
+
+find_open_parens(<<$(, Data/binary>>) -> parse_next_component(Data, #parts{});
+find_open_parens(<<_, Data/binary>>) -> find_open_parens(Data).
+
+parse_next_component(<<"FLAGS (", Data/binary>>, Parts) ->
+ parse_flags(Data, Parts);
+parse_next_component(<<"BODY[HEADER] {", Data/binary>>, Parts) ->
+ parse_header(Data, Parts);
+parse_next_component(<<"BODY[TEXT] {", Data/binary>>, Parts) ->
+ parse_body(Data, Parts);
+parse_next_component(<<_, Data/binary>>, Parts) -> parse_next_component(Data, Parts);
+parse_next_component(<<"OK Completed", _/binary>>, Parts) -> Parts;
+parse_next_component(<<>>, Parts) -> Parts.
+
+parse_flags(Data, Parts) -> parse_flags(Data, Parts, Data, 0).
+parse_flags(OrigData, Parts, <<$), Rest/binary>>, Length) ->
+ FlagsString = binary:part(OrigData, 0, Length),
+ parse_next_component(Rest, Parts#parts{ flags = FlagsString });
+parse_flags(OrigData, Parts, <<_, Data/binary>>, Length) ->
+ parse_flags(OrigData, Parts, Data, Length + 1);
+parse_flags(_OrigData, Parts, <<>>, _Length) ->
+ Parts.
+
+parse_header(Data, Parts) -> parse_header(Data, Parts, Data, 0).
+parse_header(_OrigData, Parts, <<$}, Rest/binary>>, 0) ->
+ parse_next_component(Rest, Parts);
+parse_header(OrigData, Parts, <<$}, Rest/binary>>, Length) ->
+ ByteSizeString = binary:part(OrigData, 0, Length),
+ Size = binary_to_integer(ByteSizeString),
+ HeaderString = binary:part(Rest, 2, Size), %% the 2 is for \r\n
+ %%FIXME: make sure we have enough data loaded, otherwise continue
+ Remainder = binary:part(Rest, Size, byte_size(Rest) - Size),
+ parse_next_component(Remainder, Parts#parts{ headers = HeaderString });
+parse_header(OrigData, Parts, <<_, Rest/binary>>, Length) ->
+ parse_header(OrigData, Parts, Rest, Length + 1);
+parse_header(_OrigData, Parts, <<>>, _Length) ->
+ Parts.
+
+parse_body(Data, Parts) -> parse_body(Data, Parts, Data, 0).
+parse_body(_OrigData, Parts, <<$}, Rest/binary>>, 0) ->
+ parse_next_component(Rest, Parts);
+parse_body(OrigData, Parts, <<$}, Rest/binary>>, Length) ->
+ ByteSizeString = binary:part(OrigData, 0, Length),
+ Size = binary_to_integer(ByteSizeString),
+ %%lager:info("We have ... ~p ~p ~p", [ByteSizeString, Size, byte_size(Rest)]),
+ try_body_parse(Rest, Size, Parts);
+parse_body(OrigData, Parts, <<_, Rest/binary>>, Length) ->
+ parse_body(OrigData, Parts, Rest, Length + 1);
+parse_body(_OrigData, Parts, <<>>, _Length) ->
+ Parts.
+
+try_body_parse(Data, Size, Parts) ->
+ case Size > byte_size(Data) of
+ true ->
+ { more, fun ?MODULE:continue_parse/3, #parse_state{ body_size = Size, parts = Parts, data = Data } };
+ false ->
+ Body = binary:part(Data, 2, Size), %% the 2 is for \r\n
+ Remainder = binary:part(Data, Size, byte_size(Data) - Size),
+ process_parts(parse_next_component(Remainder, Parts#parts{ body = Body }))
+ end.
+
+filter_headers(RawHeaders) ->
+ filter_headers(RawHeaders, none, none, []).
+
+filter_headers([], CurrentKey, CurrentValue, Acc) ->
+ filter_header_add(CurrentKey, CurrentValue, Acc);
+filter_headers([<<>>|Headers], CurrentKey, CurrentValue, Acc) ->
+ filter_headers(Headers, CurrentKey, CurrentValue, Acc);
+filter_headers([Header|Headers], CurrentKey, CurrentValue, Acc) ->
+ filter_header(Headers, CurrentKey, CurrentValue, Acc, binary:split(Header, <<": ">>)).
+
+filter_header(Headers, CurrentKey, CurrentValue, Acc, [Key, Value]) ->
+ Added = filter_header_add(CurrentKey, CurrentValue, Acc),
+ filter_headers(Headers, Key, Value, Added);
+filter_header(Headers, none, _CurrentValue, Acc, _Value) ->
+ filter_headers(Headers, none, none, Acc);
+filter_header(Headers, CurrentKey, CurrentValue, Acc, [Value]) ->
+ %%TODO: get rid of tab, ensure "proper" whitespace
+ NewValue = <<CurrentValue/binary, Value/binary>>,
+ filter_headers(Headers, CurrentKey, NewValue, Acc).
+
+filter_header_add(CurrentKey, CurrentValue, Acc) when CurrentKey =/= none, CurrentValue =/= none ->
+ %%TODO: split CurrentValue on ','
+ [ { CurrentKey, CurrentValue } | Acc ];
+filter_header_add(_, _, Acc) ->
+ Acc.
+

guam-0.9.11.tar.gz/_checkouts/eimap/src/commands/eimap_command_starttls.erl Added

@@ -0,0 +1,32 @@
+%% Copyright 2014 Kolab Systems AG (http://www.kolabsys.com)
+%%
+%% Aaron Seigo (Kolab Systems) <seigo a kolabsys.com>
+%%
+%% This program is free software: you can redistribute it and/or modify
+%% it under the terms of the GNU Library 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 Library General Public License for more details.
+%%
+%% You should have received a copy of the GNU Library General Public License
+%% along with this program. If not, see <http://www.gnu.org/licenses/>.
+
+-module(eimap_command_starttls).
+-behavior(eimap_command).
+-export([new_command/1, formulate_response/2]).
+
+%% http://tools.ietf.org/html/rfc2342
+
+%% Public API
+new_command(_Args) -> { <<"STARTTLS">>, single_line_response }.
+
+formulate_response(Data, Tag) ->
+ case eimap_utils:check_response_for_failure(Data, Tag) of
+ ok -> starttls;
+ { _, Reason } -> { error, Reason }
+ end.
+

guam-0.9.11.tar.gz/_checkouts/eimap/src/commands/eimap_command_status.erl Added

@@ -0,0 +1,78 @@
+%% Copyright 2014 Kolab Systems AG (http://www.kolabsys.com)
+%%
+%% Aaron Seigo (Kolab Systems) <seigo a kolabsys.com>
+%%
+%% This program is free software: you can redistribute it and/or modify
+%% it under the terms of the GNU Library 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 Library General Public License for more details.
+%%
+%% You should have received a copy of the GNU Library General Public License
+%% along with this program. If not, see <http://www.gnu.org/licenses/>.
+
+-module(eimap_command_status).
+-behavior(eimap_command).
+-export([new_command/1, process_line/2, formulate_response/2]).
+
+% https://tools.ietf.org/html/rfc5464
+
+% supported attributes: messages, recent, uidnext, uidvalidity, unseen, annotate
+% Public API
+new_command({ Folder, Attributes }) when is_list(Folder) -> new_command({ list_to_binary(Folder), Attributes });
+new_command({ <<>>, Attributes}) -> new_command({ <<"INBOX">>, Attributes });
+new_command({ Folder, []}) -> new_command({ Folder, [messages] });
+new_command({ Folder, Attributes }) when is_list(Attributes) ->
+ AttributesString = attribute_string(Attributes, <<>>),
+ { <<"STATUS ", Folder/binary, " (", AttributesString/binary, ")">>, multiline_response }.
+
+process_line(<<"* STATUS ", Data/binary>>, Acc) ->
+ process_status_items(binary:match(Data, <<"(">>),
+ binary:match(Data, <<")">>),
+ Data, Acc);
+process_line(_, Acc) -> Acc.
+
+formulate_response(Result, Data) -> eimap_command:formulate_response(Result, Data).
+
+%% Private API
+attribute_string([], <<>>) -> attribute_string(messages);
+attribute_string([], String) -> String;
+attribute_string([Attribute|Attributes], <<>>) -> 
+ Attr = attribute_string(Attribute),
+ attribute_string(Attributes, Attr);
+attribute_string([Attribute|Attributes], String) -> 
+ case attribute_string(Attribute) of
+ <<>> -> attribute_string(Attributes, String);
+ Attr -> attribute_string(Attributes, <<String/binary, " ", Attr/binary>>)
+ end.
+
+% Private API
+process_status_items(nomatch, _, _Data, Acc) -> Acc;
+process_status_items(_, nomatch, _Data, Acc) -> Acc;
+process_status_items({ Start, _ }, { End, _ }, Data, Acc) ->
+ Parts = binary:split(binary:part(Data, Start + 1, End - Start - 1), <<" ">>, [global]),
+ process_next_status_item(Parts, Acc).
+
+process_next_status_item([], Acc) -> Acc;
+process_next_status_item([_], Acc) -> Acc;
+process_next_status_item([Token, Value|Parts], Acc) ->
+ Tuple = { attribute_atom(Token), binary_to_integer(Value) },
+ process_next_status_item(Parts, [Tuple|Acc]).
+
+attribute_string(messages) -> <<"MESSAGES">>;
+attribute_string(recent) -> <<"RECENT">>;
+attribute_string(uidnext) -> <<"UIDNEXT">>;
+attribute_string(uidvalidity) -> <<"UIDVALIDITY">>;
+attribute_string(unseen) -> <<"UNSEEN">>;
+attribute_string(_) -> <<>>.
+
+attribute_atom(<<"MESSAGES">>) -> messages;
+attribute_atom(<<"RECENT">>) -> recent;
+attribute_atom(<<"UIDNEXT">>) -> uidnext;
+attribute_atom(<<"UIDVALIDITY">>) -> uidvalidity;
+attribute_atom(<<"UNSEEN">>) -> unseen.
+

guam-0.9.11.tar.gz/_checkouts/eimap/src/commands/eimap_command_switch_folder.erl Added

@@ -0,0 +1,65 @@
+%% Copyright 2014 Kolab Systems AG (http://www.kolabsys.com)
+%%
+%% Aaron Seigo (Kolab Systems) <seigo a kolabsys.com>
+%%
+%% This program is free software: you can redistribute it and/or modify
+%% it under the terms of the GNU Library 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 Library General Public License for more details.
+%%
+%% You should have received a copy of the GNU Library General Public License
+%% along with this program. If not, see <http://www.gnu.org/licenses/>.
+
+-module(eimap_command_switch_folder).
+-behavior(eimap_command).
+-export([new_command/1, process_line/2, process_tagged_line/2, formulate_response/2]).
+
+%% https://tools.ietf.org/html/rfc3501#section-6.3.2
+
+%% Public API
+new_command({ MBox, Mechanism }) when is_list(MBox) -> new_command({ list_to_binary(MBox), Mechanism });
+new_command({ MBox, select }) -> new_command(MBox);
+new_command({ MBox, examine }) -> { <<"EXAMINE \"", MBox/binary, "\"">>, all_multiline_response };
+new_command(MBox) when is_list(MBox) -> new_command(list_to_binary(MBox));
+new_command(MBox) when is_binary(MBox) -> { <<"SELECT \"", MBox/binary, "\"">>, all_multiline_response }.
+
+%TODO: parse:
+% REQUIRED untagged responses: FLAGS, EXISTS, RECENT
+% REQUIRED OK untagged responses: UNSEEN, PERMANENTFLAGS, UIDNEXT, UIDVALIDITY
+process_line(<<"* OK [", Info/binary>>, Acc) ->
+ case binary:match(Info, <<"]">>) of
+ nomatch -> Acc;
+ { ClosingBracket, _ } -> process_ok_response(binary:part(Info, 0, ClosingBracket), Acc)
+ end;
+process_line(<<"* FLAGS ", FlagString/binary>>, Acc) ->
+ Flags = eimap_utils:parse_flags(FlagString),
+ [{ flags, Flags }|Acc];
+process_line(<<"* ", Info/binary>>, Acc) ->
+ case binary:split(Info, <<" ">>) of
+ [ Value, Key ] -> [{ eimap_utils:binary_to_atom(Key), binary_to_integer(Value) }|Acc];
+ _ ->Acc
+ end;
+process_line(_Data, Acc) -> Acc.
+
+process_tagged_line(Data, Acc) ->
+ case binary:match(Data, <<"[READ-WRITE]">>) of
+ nomatch -> [{ writeable, false }|Acc];
+ _ -> [{ writeable, true}|Acc]
+ end.
+
+formulate_response(Response, Acc) -> eimap_command:formulate_response(Response, Acc).
+
+%PRIVATE
+process_ok_response(<<"PERMANENTFLAGS ", FlagString/binary>>, Acc) -> [{ permanent_flags, eimap_utils:parse_flags(FlagString) }|Acc];
+process_ok_response(<<"UIDVALIDITY ", String/binary>>, Acc) -> [{ uid_validity, binary_to_integer(String) }|Acc];
+process_ok_response(<<"UIDNEXT ", String/binary>>, Acc) -> [{ uid_next, binary_to_integer(String) }|Acc];
+process_ok_response(<<"HIGHESTMODSEQ ", String/binary>>, Acc) -> [{ highest_mod_seq, binary_to_integer(String) }|Acc];
+process_ok_response(<<"URLMECH ", String/binary>>, Acc) -> [{ url_mech, eimap_utils:binary_to_atom(String) }|Acc]; %TODO: this is very ugly
+process_ok_response(<<"ANNOTATIONS ", String/binary>>, Acc) -> [{ annotations, binary_to_integer(String) }|Acc];
+process_ok_response(String, Acc) -> lager:warning("eimap_command_select_folder: Unknown untagged OK response ~s~n", [String]), Acc.
+

guam-0.9.11.tar.gz/_checkouts/eimap/src/eimap.app.src Added

guam-0.9.11.tar.gz/_checkouts/eimap/src/eimap.erl Added

@@ -0,0 +1,533 @@
+%% Copyright 2014 Kolab Systems AG (http://www.kolabsys.com)
+%%
+%% Aaron Seigo (Kolab Systems) <seigo a kolabsys.com>
+%%
+%% This program is free software: you can redistribute it and/or modify
+%% it under the terms of the GNU Library 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 Library General Public License for more details.
+%%
+%% You should have received a copy of the GNU Library General Public License
+%% along with this program. If not, see <http://www.gnu.org/licenses/>.
+
+-module(eimap).
+-behaviour(gen_fsm).
+
+%% API
+-export([start_link/1,
+ %% passthrough mode, where data is just sent to the server blindly and
+ %% responses passed back equally blindly. in this mode the user is on
+ %% their own and better know what they are doing. can only be activated
+ %% when disconnected or idle
+ start_passthrough/2, stop_passthrough/1, passthrough_data/2,
+ %% connection management
+ connect/1, connect/3, disconnect/1,
+ %% commands
+ starttls/3,
+ capabilities/3,
+ login/5, logout/3,
+ compress/1,
+ get_server_metadata/4, get_server_metadata/6,
+ get_folder_status/5,
+ get_folder_metadata/5, get_folder_metadata/7,
+ get_folder_annotations/4,
+ peek_message_headers_and_body/5,
+ get_path_tokens/3,
+ noop/3]).
+
+%% gen_fsm callbacks
+-export([disconnected/2, idle/2, passthrough/2, wait_response/2, startingtls/2]).
+-export([init/1, handle_event/3, handle_sync_event/4, handle_info/3, terminate/3, code_change/4]).
+
+%% state record definition
+-record(state, { host, port, tls, tls_state = false, socket, server_id = <<>>,
+ command_serial = 1, command_queue = queue:new(),
+ current_command, current_mbox,
+ passthrough = false, passthrough_recv, passthrough_send_buffer = <<>>,
+ inflator, deflator, process_command_queue_guard = false,
+ command_timeout = infinity, command_timeout_timer = none }).
+-record(command, { tag, mbox, message, from, response_type, response_token, parse_state }).
+
+-define(SSL_UPGRADE_TIMEOUT, 5000).
+-define(TCP_CONNECT_TIMEOUT, 5000).
+-define(DEFAULT_COMMAND_TIMEOUT, infinity).
+
+%% public API
+start_link(Options) when is_list(Options) -> gen_fsm:start_link(?MODULE, Options, []).
+
+start_passthrough(PID, Receiver) when is_pid(Receiver) -> gen_fsm:send_all_state_event(PID, { start_passthrough, Receiver } ).
+stop_passthrough(PID) -> gen_fsm:send_all_state_event(PID, stop_passthrough).
+passthrough_data(PID, Data) when is_binary(Data) -> gen_fsm:send_all_state_event(PID, { passthrough, Data }).
+connect(PID) -> connect(PID, undefined, undefined).
+connect(PID, From, ResponseToken) -> gen_fsm:send_all_state_event(PID, { connect, From, ResponseToken }).
+disconnect(PID) -> gen_fsm:send_all_state_event(PID, disconnect).
+
+-spec compress(EImap :: pid()) -> ok.
+compress(EImap) when is_pid(EImap) ->
+ send_command_to_queue(EImap, EImap, compress, eimap_command_compress, ok).
+
+-spec starttls(EImap :: pid(), From :: pid(), ResponseToken :: any()) -> ok.
+starttls(EImap, From, ResponseToken) when is_pid(EImap) ->
+ send_command_to_queue(EImap, From, ResponseToken, eimap_command_starttls, ok).
+
+-spec capabilities(EImap :: pid(), From :: pid(), ResponseToken :: any()) -> ok.
+capabilities(EImap, From, ResponseToken) when is_pid(EImap) ->
+ send_command_to_queue(EImap, From, ResponseToken, eimap_command_capability, ok).
+
+-spec login(EImap :: pid(), From :: pid(), ResponseToken :: any(), User :: list() | binary(), Pass :: list() | binary()) -> ok.
+login(EImap, From, ResponseToken, User, Pass) ->
+ send_command_to_queue(EImap, From, ResponseToken, eimap_command_login, { User, Pass }).
+
+-spec logout(EImap :: pid(), From :: pid(), ResponseToken :: any()) -> ok.
+logout(EImap, From, ResponseToken) ->
+ send_command_to_queue(EImap, From, ResponseToken, eimap_command_logout, ok).
+
+-type status_property() :: messages | recent | uidnext | uidvalidity | unseen.
+-type status_properties() :: [status_property()].
+-spec get_folder_status(EImap :: pid(), From :: pid(), ResponseToken :: any(), Folder :: list() | binary(), Properties:: status_properties()) -> ok.
+get_folder_status(EImap, From, ResponseToken, Folder, Properties) ->
+ send_command_to_queue(EImap, From, ResponseToken, eimap_command_status, { Folder, Properties }).
+
+-spec get_folder_metadata(EImap :: pid(), From :: pid(), ResponseToken :: any(), Folder :: list() | binary(), Properties:: [list() | binary()]) -> ok.
+get_folder_metadata(EImap, From, ResponseToken, Folder, Properties) ->
+ get_folder_metadata(EImap, From, ResponseToken, Folder, Properties, infinity, nomax).
+
+-spec get_folder_metadata(EImap :: pid(), From :: pid(), ResponseToken :: any(), Folder :: list() | binary(), Properties:: [list() | binary()], Depth :: infinity | integer(), MaxSize :: nomax | integer()) -> ok.
+get_folder_metadata(EImap, From, ResponseToken, Folder, Properties, Depth, MaxSize) ->
+ send_command_to_queue(EImap, From, ResponseToken, eimap_command_getmetadata, { Folder, Properties, Depth, MaxSize }).
+
+-spec get_server_metadata(EImap :: pid(), From :: pid(), ResponseToken :: any(), Properties:: [list() | binary()]) -> ok.
+get_server_metadata(EImap, From, ResponseToken, Properties) ->
+ send_command_to_queue(EImap, From, ResponseToken, eimap_command_getmetadata, { <<>>, Properties, infinity, nomax }).
+
+-spec get_server_metadata(EImap :: pid(), From :: pid(), ResponseToken :: any(), Properties:: [list() | binary()], Depth :: infinity | integer(), MaxSize :: nomax | integer()) -> ok.
+get_server_metadata(EImap, From, ResponseToken, Properties, Depth, MaxSize) ->
+ send_command_to_queue(EImap, From, ResponseToken, eimap_command_getmetadata, { <<>>, Properties, Depth, MaxSize }).
+
+-spec get_folder_annotations(EImap :: pid(), From :: pid(), ResponseToken :: any(), Folder :: [list() | binary()]) -> ok.
+get_folder_annotations(EImap, From, ResponseToken, Folder) ->
+ send_command_to_queue(EImap, From, ResponseToken, eimap_command_annotation, Folder).
+
+-spec peek_message_headers_and_body(EImap :: pid(), From :: pid(), ResponseToken :: any(), Folder :: [list() | binary()], MessageID :: [integer() | binary()]) -> ok.
+peek_message_headers_and_body(EImap, From, ResponseToken, Folder, MessageID) ->
+ send_command_to_queue(EImap, From, ResponseToken, eimap_command_peek_message, MessageID, Folder).
+
+-spec get_path_tokens(EImap :: pid(), From :: pid(), ResponseToken :: any()) -> ok.
+get_path_tokens(EImap, From, ResponseToken) ->
+ send_command_to_queue(EImap, From, ResponseToken, eimap_command_namespace, ok).
+
+-spec noop(EImap :: pid(), From :: pid(), ResponseToken :: any()) -> ok.
+noop(EImap, From, ResponseToken) ->
+ send_command_to_queue(EImap, From, ResponseToken, eimap_command_noop, ok).
+
+
+%% gen_server API
+init(Options) ->
+ Host = proplists:get_value(host, Options, "127.0.0.1"),
+ Port = proplists:get_value(port, Options, 143),
+ TLS = proplists:get_value(tls, Options, false),
+ CommandTimeout = proplists:get_value(command_timeout, Options, ?DEFAULT_COMMAND_TIMEOUT),
+ State = #state { host = Host, port = Port, tls = TLS, command_timeout = CommandTimeout },
+ { ok, disconnected, State }.
+
+disconnected({ connect, Receiver, ResponseToken }, #state{ command_queue = CommandQueue, host = Host, port = Port, tls = TLS, socket = undefined } = State) ->
+ %lager:debug("CONNECTING! ~p ~p", [Receiver, ResponseToken]),
+ { {ok, Socket}, TlsState, SendCapabilitiesTo, NewCommandQueue } = create_socket(Host, Port, TLS, Receiver, ResponseToken, CommandQueue),
+ { Message, ResponseType } = eimap_command_capability:new_command(parse_serverid),
+ Command = #command{ message = Message, response_type = ResponseType,
+ from = SendCapabilitiesTo, response_token = { connected, Receiver, ResponseToken },
+ parse_state = eimap_command_capability },
+ { next_state, wait_response, State#state { socket = Socket, tls_state = TlsState, current_command = Command, command_queue = NewCommandQueue } };
+disconnected(Command, State) when is_record(Command, command) ->
+ { next_state, disconnected, enque_command(Command, State) }.
+
+
+%Throttle if the target process is getting overloaded.
+%This allows the socket buffers to fill up eventually,
+%so regular congestion control can kick in.
+throttle(Receiver, Limit) ->
+ {_, MessageQueueLength} = process_info(Receiver, message_queue_len),
+ if
+ MessageQueueLength > Limit ->
+ SleepDuration = trunc(MessageQueueLength / 2),
+ lager:debug("Throttling for ~p with queue length ~p", [SleepDuration, MessageQueueLength]),
+ timer:sleep(SleepDuration),
+ throttle(Receiver, Limit);
+ true -> false
+ end.
+
+passthrough(flush_passthrough_buffer, #state{ passthrough_send_buffer = Buffer } = State) ->
+ %lager:info("Passing through ~p", [Buffer]),
+ passthrough({ passthrough, Buffer }, State#state{ passthrough_send_buffer = <<>> });
+passthrough({ passthrough, Data }, #state{ socket = Socket, tls_state = true } = State) ->
+ %lager:info("Passing through ssl \"~s\"", [Data]),
+ ssl:send(Socket, deflated(Data, State)),
+ { next_state, passthrough, State };
+passthrough({ passthrough, Data }, #state{ socket = Socket } = State) ->
+ %lager:info("Passing through tcp \"~s\"", [Data]),
+ gen_tcp:send(Socket, deflated(Data, State)),
+ { next_state, passthrough, State };
+passthrough({ data, Data }, #state{ passthrough_recv = Receiver } = State) ->
+ %lager:info("Passing back ~p", [Data]),
+
+ throttle(Receiver, 100),
+ Receiver ! { imap_server_response, Data },
+ { next_state, passthrough, State };
+passthrough(Command, State) when is_record(Command, command) ->
+ NewState = ensure_process_command_queue(State),
+ { next_state, idle, enque_command(Command, NewState) }.
+
+idle(process_command_queue, #state{ command_queue = Queue } = State) ->
+ UnguardedState = State#state{ process_command_queue_guard = false },
+ case queue:out(Queue) of
+ { { value, Command }, ModifiedQueue } when is_record(Command, command) ->
+ %lager:info("Clearing queue of ~p", [Command]),
+ NewState = send_command(Command, UnguardedState#state{ command_queue = ModifiedQueue }),
+ { next_state, wait_response, NewState };
+ { empty, _ModifiedQueue } ->
+ NextState = next_state_after_emptied_queue(State),
+ { next_state, NextState, UnguardedState }
+ end;
+idle({ data, _Data }, State) ->
+ %%lager:info("Idling, server sent: ~p", [_Data]),
+ { next_state, idle, State };
+idle(Command, State) when is_record(Command, command) ->
+ %%lager:info("Idling"),
+ NewState = send_command(Command, State),
+ { next_state, wait_response, NewState };
+idle(_Event, State) ->
+ { next_state, idle, ensure_process_command_queue(State) }.
+
+
+next_state_after_emptied_queue(#state{ passthrough = true }) ->
+ gen_fsm:send_event(self(), flush_passthrough_buffer),
+ passthrough;
+next_state_after_emptied_queue(_State) ->
+ idle.
+
+ensure_process_command_queue(State) ->
+ case State#state.process_command_queue_guard of
+ true ->
+ State;
+ _ ->
+ gen_fsm:send_event(self(), process_command_queue),
+ State#state{ process_command_queue_guard = true }
+ end.
+
+%%TODO a variant that checks "#command{ from = undefined }" to avoid parsing responses which will go undelivered?
+wait_response(Command, State) when is_record(Command, command) ->
+ { next_state, wait_response, enque_command(Command, State) };
+wait_response({ data, _Data }, #state{ current_command = #command{ parse_state = undefined } } = State) ->
+ NewState = cancel_timeout(State),
+ { next_state, idle, ensure_process_command_queue(NewState) };
+wait_response({ data, Data }, #state{ current_command = #command{ response_type = ResponseType, parse_state = CommandState , tag = Tag } } = State) ->
+ Response = eimap_command:parse_response(ResponseType, Data, Tag, CommandState),
+ %%lager:info("Response from parser was ~p ~p, size of queue ~p", [More, Response, queue:len(State#state.command_queue)]),
+ % FIXME
+ % Because several commands can be in flight at the same time, it can happen that we have something like:
+ % * Client send: CMD1, CMD2 (triggering a request for metadata)
+ % * Because we immediately after processing CMD2 from the client request metadata and start waiting for the response,
+ % a response that actually still belongs to CMD1 will not be recognized as such (will end up in here).
+ %
+ % Below is a workaround for that case; If we fail to parse the repsonse we simply assume it's none of our business and pass it trough.
+ %
+ % For a proper fix more work would be required, here are some ideas:
+ % * Track pending tags and only start associating with this command once we have all outstanding tags completed. The problem is that we don't know about pending tags because normally we don't look for them while passing through.
+ % * Buffer data and watch out for any tag. If its not ours pass the data through (would result in performance penalty only while waiting for the command).
+ case Response of
+ {more,{<<>>,[],_}} -> passthrough({data, Data}, State);
+ _ -> {}
+ end,
+ NewState = cancel_timeout(State),
+ next_command_after_response(Response, NewState);
+wait_response(process_command_queue, State) ->
+ % ignore this one, we'll get to it when the response comes
+ { next_state, wait_response, State }.
+
+startingtls({ passthrough, Data }, #state{ passthrough = true, passthrough_send_buffer = Buffer } = State) ->
+ { next_state, startingtls, State#state{ passthrough_send_buffer = <<Buffer/binary, Data>> } };
+startingtls(Command, State) when is_record(Command, command) ->
+ { next_state, startingtls, enque_command(Command, State) };
+startingtls({ data, Data }, #state{ current_command = #command{ response_type = ResponseType, parse_state = CommandState, tag = Tag } } = State) ->
+ Response = eimap_command:parse_response(ResponseType, Data, Tag, CommandState),
+ %%lager:info("Response from parser was ~p ~p, size of queue ~p", [More, Response, queue:len(State#state.command_queue)]),
+ next_command_after_response(Response, State).
+
+handle_event({ connect, _From, _ResponseToken } = Event, disconnected, State) ->
+ gen_fsm:send_event(self(), Event),
+ { next_state, disconnected, State };
+handle_event({ connect, _From, _ResponseToken }, _Statename, State) ->
+ %%lager:info("Already connected to IMAP server!"),
+ { next_state, _Statename, State };
+handle_event(disconnect, _StateName, State) ->
+ close_socket(State),
+ { next_state, disconnected, reset_state(State) };
+handle_event({ ready_command, Command }, StateName, State) when is_record(Command, command) ->
+ ?MODULE:StateName(Command, State);
+handle_event({ start_passthrough, Receiver }, StateName, State) ->
+ { next_state, StateName, State#state{ passthrough = true, passthrough_recv = Receiver } };
+handle_event(stop_passthrough, StateName, State) ->
+ { NextStateName, NewState } = case StateName of
+ passthrough -> { idle, ensure_process_command_queue(State) };
+ StateName -> { StateName, State }
+ end,
+ { next_state, NextStateName, NewState#state{ passthrough = false } };
+handle_event({ passthrough, Data }, passthrough, #state{ passthrough = true } = State) ->
+ ?MODULE:passthrough({ passthrough, Data }, State);
+handle_event({ passthrough, Data }, StateName, #state{ passthrough = true, passthrough_send_buffer = Buffer } = State) ->
+ NewBuffer = <<Buffer/binary, Data/binary>>,
+ NewState =
+ case StateName of
+ idle -> ensure_process_command_queue(State);
+ _ -> State
+ end,
+ { next_state, StateName, NewState#state{ passthrough_send_buffer = NewBuffer } };
+handle_event(_Event, StateName, State) -> { next_state, StateName, State}.
+
+handle_sync_event(_Event, _From, StateName, State) -> { next_state, StateName, State}.
+
+handle_info({ ssl, Socket, Bin }, StateName, #state{ socket = Socket } = State) ->
+ % Flow control: enable forwarding of next TCP message
+ ssl:setopts(Socket, [{ active, once }]),
+ Data = inflated(Bin, State),
+ %lager:info("Received from server over ssl: ~s", [Data]),
+ ?MODULE:StateName({ data, Data }, State);
+handle_info({ tcp, Socket, Bin }, StateName, #state{ socket = Socket } = State) ->
+ % Flow control: enable forwarding of next TCP message
+ inet:setopts(Socket, [{ active, once }]),
+ Data = inflated(Bin, State),
+ %lager:info("Received from server plaintext: ~s", [Data]),
+ ?MODULE:StateName({ data, Data }, State);
+handle_info({ ssl_closed, Socket }, _StateName, #state{ socket = Socket, host = Host, port = Port } = State) ->
+ lager:debug("~p Disconnected from ~p:~p .\n", [self(), Host, Port]),
+ { stop, normal, State };
+handle_info({ ssl_error, Socket, _Reason }, _StateName, #state{ socket = Socket, host = Host, port = Port } = State) ->
+ lager:info("~p Disconnected due to socket error from ~p:~p .\n", [self(), Host, Port]),
+ { stop, normal, State };
+handle_info({ tcp_closed, Socket }, _StateName, #state{ socket = Socket, host = Host, port = Port } = State) ->
+ lager:debug("~p Disconnected from ~p:~p .\n", [self(), Host, Port]),
+ { stop, normal, State };
+handle_info({ tcp_error, Socket, _Reason }, _StateName, #state{ socket = Socket, host = Host, port = Port } = State) ->
+ lager:info("~p Disconnected due to socket error from ~p:~p .\n", [self(), Host, Port]),
+ { stop, normal, State };
+handle_info({ { connected, Receiver, ResponseToken }, { Capabilities, ServerID } }, _StateName, #state{ passthrough = Passthrough, passthrough_recv = PassthroughReceiver, tls = TLS } = State) ->
+ case TLS of
+ starttls ->
+ % we do not pass through or notifty when we are going to automatically do a starttls
+ % this allows us to send the post-starttls capabilities triggering client activity
+ % only AFTER we have completely set up the connectiona, as that usually tends to
+ % alter the capabilities
+ %
+ % if the user of eimap does not want this behavior, they can starttls themselves
+ % explicitly
+ ok;
+ _ ->
+ %lager:debug("Connected, capabilities are: ~s; ServerID is ~s", [Capabilities, ServerID]),
+ send_hello_string(Capabilities, ServerID, Receiver, ResponseToken, Passthrough, PassthroughReceiver)
+ end,
+ { next_state, idle, State#state{ current_command = undefined, server_id = ServerID } };
+handle_info({ { posttls_capabilities, Receiver, ResponseToken }, [Capabilities] }, _StateName, #state{ server_id = ServerID, passthrough = Passthrough, passthrough_recv = PassthroughReceiver } = State) ->
+ send_hello_string(Capabilities, ServerID, Receiver, ResponseToken, Passthrough, PassthroughReceiver),
+ { next_state, idle, State#state{ current_command = none } };
+handle_info({ { selected, MBox }, ok }, StateName, State) ->
+ %%lager:info("~p Selected mbox ~p", [self(), MBox]),
+ { next_state, StateName, State#state{ current_mbox = MBox } };
+handle_info({ { selected, MBox }, { error, Reason } }, StateName, State) ->
+ lager:info("Failed to select mbox ~p: ~p", [MBox, Reason]),
+ NewQueue = queue:filter(fun(Command) -> notify_of_mbox_failure_during_filter(Command, Command#command.mbox =:= MBox) end, State#state.command_queue),
+ { next_state, StateName, State#state{ command_queue = NewQueue } };
+handle_info(starttls_complete, StateName, State) ->
+ %lager:info("STARTTLS completed successfully"),
+ { next_state, StateName, State };
+handle_info(response_timeout, _StateName, State) ->
+ { stop, normal, State };
+handle_info(Info, StateName, State) ->
+ lager:debug("handle_info called with unhandled info of ~p", [Info]),
+ { next_state, StateName, State }.
+
+terminate(_Reason, _Statename, State) -> close_socket(State), ok.
+
+code_change(_OldVsn, Statename, State, _Extra) -> { ok, Statename, State }.
+
+%% private API
+send_command_to_queue(EImap, From, ResponseToken, Module, Args) ->
+ send_command_to_queue(EImap, From, ResponseToken, Module, Args, undefined).
+send_command_to_queue(EImap, From, ResponseToken, Module, Args, Folder) ->
+ { Message, ResponseType } = Module:new_command(Args),
+ Command = #command{ mbox = Folder, message = Message, response_type = ResponseType,
+ from = From, response_token = ResponseToken,
+ parse_state = Module },
+ gen_fsm:send_all_state_event(EImap, { ready_command, Command }).
+
+send_hello_string(Capabilities, ServerId, Receiver, ResponseToken, Passthrough, PassthroughReceiver) ->
+ notify_of_response([{ capabilities, Capabilities }, { server_id, ServerId } ], Receiver, ResponseToken),
+ passthrough_capabilities(Capabilities, ServerId, Passthrough, PassthroughReceiver).
+
+passthrough_capabilities(Capabilities, ServerId, true, Receiver) ->
+ Message = <<"* OK [CAPABILITY ", Capabilities/binary, "] ", ServerId/binary, "\r\n">>,
+ Receiver ! { imap_server_response, Message };
+passthrough_capabilities(_Capabilities, _ServerId, _Passthrough, _Receiver) -> ok.
+
+notify_of_response(none, _Command) -> ok;
+notify_of_response(Response, #command { from = From, response_token = Token }) -> notify_of_response(Response, From, Token);
+notify_of_response(_, _) -> ok.
+
+notify_of_response(_Response, undefined, _Token) -> ok;
+notify_of_response(Response, From, undefined) -> From ! Response;
+notify_of_response(Response, From, Token) -> From ! { Token, Response }.
+
+%% the return is inverted for filtering
+notify_of_mbox_failure_during_filter(Command, true) -> notify_of_response({ error, mailboxnotfound }, Command), false;
+notify_of_mbox_failure_during_filter(_Command, false) -> true.
+
+next_command_after_response({ more, ParseState }, State) ->
+ { next_state, wait_response, State#state{ current_command = State#state.current_command#command{ parse_state = ParseState } } };
+next_command_after_response({ error, _ } = ErrorResponse, State) ->
+ notify_of_response(ErrorResponse, State#state.current_command),
+ NewState = ensure_process_command_queue(State),
+ { next_state, idle, NewState#state{ current_command = undefined } };
+next_command_after_response({ fini, Response }, State) ->
+ %lager:info("Notifying with ~p", [State#state.current_command]),
+ notify_of_response(Response, State#state.current_command),
+ NewState = ensure_process_command_queue(State),
+ { next_state, idle, NewState#state{ current_command = undefined } };
+next_command_after_response(starttls, State) ->
+ { TLSState, Socket } = upgrade_socket(State),
+ %lager:info("~p Upgraded the socket ...", [self()]),
+ NewState = ensure_process_command_queue(State),
+ { next_state, idle, NewState#state{ current_command = undefined, socket = Socket, tls_state = TLSState } };
+next_command_after_response(compression_active, State) ->
+ { Inflator, Deflator } = eimap_utils:new_imap_compressors(),
+ NewState = ensure_process_command_queue(State),
+ { next_state, idle, NewState#state{ current_command = undefined, inflator = Inflator, deflator = Deflator } };
+next_command_after_response({ close_socket, Response }, State) ->
+ notify_of_response(Response, State#state.current_command),
+ { stop, normal, State }.
+
+tag_field_width(Serial) when Serial < 10000 -> 4;
+tag_field_width(Serial) -> tag_field_width(Serial / 10000, 5).
+tag_field_width(Serial, Count) when Serial < 10 -> Count;
+tag_field_width(Serial, Count) -> tag_field_width(Serial / 10, Count + 1).
+
+create_socket(Host, Port, true, _Receiver, _ResponseToken, CommandQueue) ->
+ { ssl:connect(Host, Port, socket_options(), ?SSL_UPGRADE_TIMEOUT), true, self(), CommandQueue };
+create_socket(Host, Port, starttls, Receiver, ResponseToken, CommandQueue) ->
+ %lager:debug("Setting up the tls creation with ultimate end point of ~p ~p", [Receiver, ResponseToken]),
+ % we do an implicit TLS by adding a starttls command and then a capability command so we can
+ % pretend to the user that the socket just magically opened up like this.
+ %TODO: some duplicated code here; would be nice to clean this up a bit?
+ { TlsMessage, TlsResponseType } = eimap_command_starttls:new_command(ok),
+ TlsCommand = #command{ message = TlsMessage, response_type = TlsResponseType,
+ from = self(), response_token = undefined,
+ parse_state = eimap_command_starttls },
+ { CapMessage, CapResponseType } = eimap_command_capability:new_command(ok),
+ CapabilitiesCommand = #command{ message = CapMessage, response_type = CapResponseType,
+ from = self(), response_token = { posttls_capabilities, Receiver, ResponseToken },
+ parse_state = eimap_command_capability },
+ % note the use of queue:in_r to _prepend_ the commands so they get run first even if the user
+ % has pre-connection queued up commands
+ NewCommandQueue = queue:in_r(TlsCommand, queue:in_r(CapabilitiesCommand, CommandQueue)),
+ { gen_tcp:connect(Host, Port, socket_options(), ?TCP_CONNECT_TIMEOUT), false, self(), NewCommandQueue };
+create_socket(Host, Port, _, _Receiver, _ResponseToken, CommandQueue) ->
+ { gen_tcp:connect(Host, Port, socket_options(), ?TCP_CONNECT_TIMEOUT), false, self(), CommandQueue }.
+
+socket_options() -> [binary, { active, once }, { send_timeout, 5000 }, { keepalive, true }].
+
+upgrade_socket(#state{ socket = Socket, tls_state = true, current_command = Command }) ->
+ notify_of_response(starttls_complete, Command),
+ ssl:setopts(Socket, [{ active, once }]),
+ { true, Socket };
+upgrade_socket(#state{ socket = Socket, current_command = Command }) ->
+ %lager:debug("~p upgrading the server socket due to starttls"[self()]),
+ case ssl:connect(Socket, socket_options(), ?SSL_UPGRADE_TIMEOUT) of
+ { ok, SSLSocket } ->
+ %lager:info("~p it worked", [self()]),
+ notify_of_response(starttls_complete, Command),
+ ssl:setopts(SSLSocket, [{ active, once }]),
+ { true, SSLSocket };
+ { error, Reason } ->
+ lager:warning("~p StartTLS failed due to: ~p", [self(), Reason]),
+ notify_of_response(starttls_failed, Command),
+ inet:setopts(Socket, [{ active, once }]),
+ { false, Socket }
+ end.
+
+close_socket(#state{ socket = undefined }) -> false;
+close_socket(#state{ socket = Socket, tls_state = true }) -> ssl:close(Socket);
+close_socket(#state{ socket = Socket }) -> gen_tcp:close(Socket).
+
+reset_state(State) -> State#state{ socket = undefined, command_serial = 1 }.
+
+%% sending command code paths:
+%% 0. not connected, TLS/SSL, unencrypted
+%% 1. no mbox needed, mbox is already selected, mbox needs selecting
+send_command(Command, #state{ socket = undefined } = State) ->
+ lager:warning("Not connected, dropping command on floor: ~s", [Command]),
+ State;
+send_command(Command, #state{ tls_state = true} = State) ->
+ send_command(fun ssl:send/2, Command, State);
+send_command(Command, State) ->
+ send_command(fun gen_tcp:send/2, Command, State).
+
+send_command(SocketFun, #command{ mbox = undefined } = Command, State) ->
+ %%lager:info("~p SELECT_DEBUG issuing command without mbox: ~p", [self(), Command#command.message]),
+ send_command_now(SocketFun, Command, State);
+send_command(SocketFun, #command{ mbox = MBox } = Command, #state{ current_mbox = CurrentMbox } = State) ->
+ %%lager:info("~p SELECT_DEBUG issuing command with mbox ~p (current: ~p, equal -> ~p): ~p", [self(), MBox, CurrentMbox, (MBox =:= CurrentMbox), Command#command.message]),
+ send_command_or_select_mbox(SocketFun, Command, State, MBox, MBox =:= CurrentMbox).
+
+send_command_or_select_mbox(SocketFun, Command, State, _MBox, true) ->
+ send_command_now(SocketFun, Command, State);
+send_command_or_select_mbox(SocketFun, DelayedCommand, State, MBox, false) ->
+ NextState = reenque_command(DelayedCommand, State),
+ %TODO: this really should be SELECT rather than EXAMINE
+ { SelectMessage, ResponseType } = eimap_command_switch_folder:new_command(MBox),
+ SelectCommand = #command{ message = SelectMessage, response_type = ResponseType,
+ parse_state = eimap_command_switch_folder,
+ from = self(), response_token = { selected, MBox } },
+ %%lager:info("~p SELECT_DEBUG: Doing a select first ~p", [self(), SelectMessage]),
+ send_command_now(SocketFun, SelectCommand, NextState).
+
+send_command_now(SocketFun, #command{ message = Message } = Command, #state{ command_serial = Serial, socket = Socket } = State) ->
+ Tag = list_to_binary(io_lib:format("EG~*..0B", [tag_field_width(Serial), Serial])),
+ Data = <<Tag/binary, " ", Message/binary, "\r\n">>,
+ %lager:info("Sending command via ~p: ~s", [Fun, Data]),
+ SocketFun(Socket, deflated(Data, State)),
+ StateWithTimeout = reset_timeout(State),
+ StateWithTimeout#state{ command_serial = Serial + 1, current_command = Command#command{ tag = Tag } }.
+
+enque_command(Command, State) ->
+ %%lager:info("Enqueuing command ~p", [Command]),
+ State#state { command_queue = queue:in(Command, State#state.command_queue) }.
+
+reenque_command(Command, State) ->
+ %%lager:info("Re-queueing command ~p", [Command]),
+ State#state { command_queue = queue:in_r(Command, State#state.command_queue) }.
+
+inflated(Data, #state{ inflator = undefined }) -> Data;
+inflated(Data, #state{ inflator = Inflator }) -> iolist_to_binary(zlib:inflate(Inflator, Data)).
+
+deflated(Data, #state{ deflator = undefined }) -> Data;
+deflated(Data, #state{ deflator = Deflator }) -> iolist_to_binary(zlib:deflate(Deflator, Data, sync)).
+
+reset_timeout(#state{ command_timeout = Timeout } = State) ->
+ cancel_timeout(State),
+ { ok, TimerRef } =
+ case Timeout of
+ Timeout when is_integer(Timeout), Timeout >= 0 ->
+ timer:send_after(Timeout, response_timeout);
+ _ ->
+ { ok, none }
+ end,
+ State#state{ command_timeout_timer = TimerRef }.
+
+cancel_timeout(#state{ command_timeout_timer = none } = State) -> State;
+cancel_timeout(#state{ command_timeout_timer = TimerRef } = State) ->
+ timer:cancel(TimerRef),
+ State#state{ command_timeout_timer = none }.
+

guam-0.9.11.tar.gz/_checkouts/eimap/src/eimap_command.erl Added

@@ -0,0 +1,78 @@
+-module(eimap_command).
+
+-export([
+ parse_response/4,
+ formulate_response/2,
+ process_status_line/2
+ ]).
+
+-type more_tuple() :: { more, ParseContinuation :: parse_continuation(), State :: term }.
+-type finished_tuple() :: { fini, Results :: term }.
+-type error_tuple() :: { error, Reason :: binary() }.
+-type parse_continuation() :: fun((Data :: binary(), Tag :: binary(), State :: term()) ->
+ more_tuple() | finished_tuple() | error_tuple()).
+
+-callback new_command(Args :: any()) -> { binary(), single_line_response | multiline_reponse | blob_response }.
+% TODO:bring back when we can depend on OTP 18 which introduced optional_callback
+% also define parse/2 (for blob_response), formulate_response/2
+%-callback process_line(Data :: binary(), Acc :: any()) ->
+% more_tuple() | finished_tuple() | error_tuple() | starttls.
+
+parse_response(multiline_response, Data, Tag, ParseState) -> multiline_parse(false, Data, Tag, ParseState);
+parse_response(all_multiline_response, Data, Tag, ParseState) -> multiline_parse(parse_tagged, Data, Tag, ParseState);
+parse_response(single_line_response, Data, Tag, Module) -> Module:formulate_response(Data, Tag);
+parse_response(blob_response, Data, Tag, { Continuation, ParseState }) -> Continuation(Data, Tag, ParseState);
+parse_response(blob_response, Data, Tag, Module) ->
+ case Module:parse(Data, Tag) of
+ { more, Continuation, ParseState } -> { more, { Continuation, ParseState } };
+ Response -> Response
+ end.
+
+multiline_parse(ParseTaggedLine, Data, Tag, { LastPartialLine, Acc, Module }) ->
+ FullBuffer = <<LastPartialLine/binary, Data/binary>>,
+ { FullLinesBuffer, NewLastPartialLine } = eimap_utils:only_full_lines(FullBuffer),
+ Lines = binary:split(FullLinesBuffer, <<"\r\n">>, [global]),
+ process_lines(ParseTaggedLine, Tag, NewLastPartialLine, Lines, Acc, Module);
+multiline_parse(ParseTaggedLine, Data, Tag, Module) ->
+ multiline_parse(ParseTaggedLine, Data, Tag, { <<>>, [], Module }).
+
+process_lines(_ParseTaggedLine, _Tag, LastPartialLine, [], Acc, Module) -> { more, { LastPartialLine, Acc, Module } };
+process_lines(ParseTaggedLine, Tag, LastPartialLine, [Line|MoreLines], Acc, Module) ->
+ { FirstLine, ContinuationBytes } = eimap_utils:num_literal_continuation_bytes(Line),
+ process_line(ContinuationBytes, ParseTaggedLine, eimap_utils:is_tagged_response(FirstLine, Tag), Tag, LastPartialLine, FirstLine, MoreLines, Acc, Module).
+
+
+process_line(ContinuationBytes, ParseTaggedLine, IsTagged, Tag, LastPartialLine, Line, [<<>>|MoreLines], Acc, Module) ->
+ %% skip empty lines
+ process_line(ContinuationBytes, ParseTaggedLine, IsTagged, Tag, LastPartialLine, Line, MoreLines, Acc, Module);
+process_line(0, ParseTaggedLine, tagged, Tag, _LastPartialLine, Line, _MoreLines, Acc, Module) ->
+ Checked = eimap_utils:check_response_for_failure(Line, Tag),
+ Module:formulate_response(Checked, parse_tagged(Checked, ParseTaggedLine, Line, Acc, Module));
+process_line(0, ParseTaggedLine, untagged, Tag, LastPartialLine, Line, MoreLines, Acc, Module) ->
+ %io:format("Calling it here with ~p~n~n...", [Line]),
+ process_lines(ParseTaggedLine, Tag, LastPartialLine, MoreLines, Module:process_line(Line, Acc), Module);
+process_line(ContinuationBytes, ParseTaggedLine, _IsTagged, Tag, LastPartialLine, Line, [], Acc, Module) ->
+ %% the line was continued, but there is no more lines ... so this line is now our last partial line. more must be on its way
+ io:format("Missing lines!~p~n~n", [Acc]),
+ BytesAsBinary = integer_to_binary(ContinuationBytes),
+ process_lines(ParseTaggedLine, Tag, <<Line/binary, ${, BytesAsBinary/binary, $}, LastPartialLine/binary>>, [], Acc, Module);
+process_line(_ContinuationBytes, ParseTaggedLine, IsTagged, Tag, LastPartialLine, Line, [NextLine|MoreLines], Acc, Module) ->
+ { StrippedNextLine, NextContinuationBytes } = eimap_utils:num_literal_continuation_bytes(NextLine),
+ io:format("Connected up the next line: ~p ~i~n", [StrippedNextLine, NextContinuationBytes]),
+ FullLine = <<Line/binary, StrippedNextLine/binary>>,
+ process_line(NextContinuationBytes, ParseTaggedLine, IsTagged, Tag, LastPartialLine, FullLine, MoreLines, Acc, Module).
+
+formulate_response(ok, Data) -> { fini, Data };
+formulate_response({ _, Reason }, _Data) -> { error, Reason }.
+
+parse_tagged(_, false, _Line, Acc, _Module) -> Acc; % we are not passing the tagged line forward (no content, e.g)
+parse_tagged(ok, _, Line, Acc, Module) -> Module:process_tagged_line(Line, Acc); % success, so pass it forward
+parse_tagged(_Checked, _ParsedTaggedLine, _Line, Acc, _Module) -> Acc. % error, don't bother passing it forward
+
+-spec process_status_line(Line :: binary(), Acc :: list()) -> NewAcc :: list().
+process_status_line(<<"* ", Rest/binary>>, Acc) -> process_matched_status_line(binary:split(Rest, <<" ">>, [global]), Acc);
+process_status_line(_, Acc) -> Acc.
+
+process_matched_status_line([Number, Key|_], Acc) -> [{ eimap_utils:binary_to_atom(Key), binary_to_integer(Number) }|Acc];
+process_matched_status_line(_, Acc) -> Acc.
+

guam-0.9.11.tar.gz/_checkouts/eimap/src/eimap_uidset.erl Added

@@ -0,0 +1,80 @@
+%% Copyright 2014 Kolab Systems AG (http://www.kolabsys.com)
+%%
+%% Aaron Seigo (Kolab Systems) <seigo a kolabsys.com>
+%%
+%% This program is free software: you can redistribute it and/or modify
+%% it under the terms of the GNU Library 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 Library General Public License for more details.
+%%
+%% You should have received a copy of the GNU Library General Public License
+%% along with this program. If not, see <http://www.gnu.org/licenses/>.
+
+-module(eimap_uidset).
+-export([uid_list_to_binary/1, empty_uidset/0, parse/1, next_uid/1]).
+
+% for internal use only
+-export([add_uid_as_binary_to_list/2, stitch_bin_list/2]).
+
+%% tokens have the form: integer | { integer, integer }
+-record(uidset, { tokens = [], current = none }).
+
+uid_list_to_binary(UidList) when is_list(UidList) ->
+ ListOfBins = lists:foldl(fun ?MODULE:add_uid_as_binary_to_list/2, [], UidList),
+ lists:foldl(fun ?MODULE:stitch_bin_list/2, <<>>, ListOfBins);
+uid_list_to_binary(_UidList) -> <<>>.
+
+parse(UidSet) when is_list(UidSet) -> parse(list_to_binary(UidSet));
+parse(<<>>) -> badarg;
+parse(UidSet) when is_binary(UidSet) ->
+ Components = binary:split(UidSet, <<",">>, [global]),
+ try lists:foldl(fun(Component, Acc) -> add_component(binary:split(Component, <<":">>), Acc) end, [], Components) of
+ Parsed -> #uidset{ tokens = lists:reverse(Parsed) }
+ catch
+ _:_ -> badarg
+ end.
+
+empty_uidset() -> #uidset{}.
+
+next_uid(#uidset{ tokens = Tokens, current = Current }) -> next_uid(Tokens, Current).
+next_uid([], _Current) -> { none, #uidset {} };
+next_uid([{ First, Second }|_] = FullList, Current) -> next_in_range(FullList, First, Second, Current);
+next_uid([Uid|UidSet], _Current) -> { Uid, #uidset{ tokens = UidSet } }.
+
+% PRIVATE API
+add_uid_as_binary_to_list(Uid, Acc) when is_integer(Uid), Uid >= 0 -> [integer_to_binary(Uid)|Acc];
+add_uid_as_binary_to_list({ StartUid, EndUid }, Acc) when is_integer(StartUid), is_integer(EndUid) ->
+ case add_uid_range_as_binary_to_list(StartUid, EndUid) of
+ error -> Acc;
+ { Start, End } -> [<<Start/binary, ":", End/binary>>|Acc]
+ end;
+add_uid_as_binary_to_list(_, Acc) -> Acc.
+
+add_uid_range_as_binary_to_list(Start, End) when Start < 0; End < 0 -> error;
+add_uid_range_as_binary_to_list(Start, End) when Start < End -> { integer_to_binary(Start), integer_to_binary(End) };
+add_uid_range_as_binary_to_list(Start, End) -> { integer_to_binary(End), integer_to_binary(Start) }.
+
+stitch_bin_list(Uid, <<>>) -> Uid;
+stitch_bin_list(Uid, Acc) -> <<Uid/binary, ",", Acc/binary>>.
+
+add_component(Uid, Acc) when is_integer(Uid), Uid >= 0 -> [Uid|Acc];
+add_component([First, Second], Acc) -> add_component(binary_to_integer(First), binary_to_integer(Second), Acc);
+add_component([<<"">>], Acc) -> Acc;
+add_component([Single], Acc) when is_binary(Single) -> add_component(binary_to_integer(Single), Acc);
+add_component(_, _Acc) -> throw(badarg).
+
+add_component(First, Second, Acc) when is_integer(First), First >= 0, is_integer(Second), Second >= 0 -> add_range(First, Second, Acc);
+add_component(_, _, _Acc) -> throw(badarg).
+
+add_range(First, Second, Acc) when First == Second -> [First|Acc];
+add_range(First, Second, Acc) -> [{ First, Second }|Acc].
+
+next_in_range(Tokens, First, _Second, none) -> { First, #uidset{ tokens = Tokens, current = First } };
+next_in_range(Tokens, First, Second, Current) when First < Second, Current < Second -> Next = Current + 1, { Next, #uidset{ tokens = Tokens, current = Next } };
+next_in_range(Tokens, First, Second, Current) when First > Second, Current > Second -> Next = Current - 1, { Next, #uidset{ tokens = Tokens, current = Next } };
+next_in_range([_|Tokens], _First, _Second, _Current) -> next_uid(#uidset{ tokens = Tokens }).

guam-0.9.11.tar.gz/_checkouts/eimap/src/eimap_utils.erl Added

@@ -0,0 +1,258 @@
+%% Copyright 2014 Kolab Systems AG (http://www.kolabsys.com)
+%%
+%% Aaron Seigo (Kolab Systems) <seigo a kolabsys.com>
+%%
+%% This program is free software: you can redistribute it and/or modify
+%% it under the terms of the GNU Library 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 Library General Public License for more details.
+%%
+%% You should have received a copy of the GNU Library General Public License
+%% along with this program. If not, see <http://www.gnu.org/licenses/>.
+
+-module(eimap_utils).
+-export([
+ extract_path_from_uri/3, extract_uidset_from_uri/1,
+ split_command_into_components/1, is_tagged_response/2, remove_tag_from_response/3,
+ header_name/1, parse_flags/1,
+ check_response_for_failure/2,
+ ensure_binary/1,
+ new_imap_compressors/0,
+ only_full_lines/1,
+ binary_to_atom/1,
+ num_literal_continuation_bytes/1
+ ]).
+
+%% Translate the folder name in to a fully qualified folder path such as it
+%% would be used by a cyrus administrator.
+-spec extract_path_from_uri(SharedPrefix :: binary(), HierarchyDelim :: binary, URI :: binary()) -> Path :: binary() | bad_uri.
+extract_path_from_uri(SharedPrefix, HierarchyDelim, URI) when is_binary(URI) ->
+ extract_path_from_uri(SharedPrefix, HierarchyDelim, binary_to_list(URI));
+extract_path_from_uri(SharedPrefix, HierarchyDelim, URI) when is_list(URI) ->
+ %%lager:info("Parsing ~p", [URI]),
+ SchemeDefaults = [{ imap, 143 }, { imaps, 993 }],
+ ParseOpts = [ { scheme_defaults, SchemeDefaults } ],
+ case imap_folder_path(SharedPrefix, HierarchyDelim, http_uri:parse(URI, ParseOpts)) of
+ Path when is_list(Path) -> list_to_binary(Path);
+ Error -> Error
+ end.
+
+-spec extract_uidset_from_uri(URI :: binary()) -> UIDSet:: binary().
+extract_uidset_from_uri(URI) when is_binary(URI) ->
+ { TagStart, TagEnd } = binary:match(URI, <<";UID=">>),
+ UIDStart = TagStart + TagEnd + 1,
+ UriLength = byte_size(URI),
+ case binary:match(URI, <<";">>, [{ scope, { UIDStart, UriLength - UIDStart } }]) of
+ nomatch -> binary:part(URI, UIDStart - 1, UriLength - UIDStart + 1);
+ { Semicolon, _ } -> binary:part(URI, UIDStart - 1, Semicolon - UIDStart + 1)
+ end.
+
+-spec header_name(mailbox_uid | groupware_uid | groupware_uid) -> binary(); (any()) -> unknown.
+header_name(mailbox_uid) -> <<"/vendor/cmu/cyrus-imapd/uniqueid">>;
+header_name(groupware_type) -> <<"X-Kolab-Type">>;
+header_name(groupware_uid) -> <<"Subject">>;
+header_name(_) -> unknown.
+
+-spec parse_flags(FlagString :: binary() | list()) -> Flags :: [binary()].
+parse_flags(String) when is_list(String) -> parse_flags(list_to_binary(String));
+parse_flags(<<"(", Parened/binary>>) ->
+ case binary:match(Parened, <<")">>) of
+ nomatch -> [];
+ { ClosingParens, _ } -> parse_flags(binary_part(Parened, 0, ClosingParens))
+ end;
+parse_flags(<<>>) -> [];
+parse_flags(FlagString) when is_binary(FlagString) ->
+ binary:split(FlagString, <<" ">>, [global]).
+
+-spec check_response_for_failure(Data :: binary(), Tag :: undefined | binary()) -> ok | { error, Reason :: binary() }.
+check_response_for_failure(Data, undefined) when is_binary(Data) ->
+ check_response_for_failure(Data, <<>>);
+check_response_for_failure(Data, Tag) when is_binary(Data), is_binary(Tag) ->
+ NoToken = <<Tag/binary, " NO ">>,
+ NoTokenLength = byte_size(NoToken),
+ case NoTokenLength > byte_size(Data) of
+ true -> ok;
+ false -> is_no_token_found(Data, Tag, binary:match(Data, NoToken, [ { scope, { 0, NoTokenLength } } ]))
+ end.
+
+-spec split_command_into_components(Buffer :: binary()) -> { Tag :: binary(), Command :: binary(), Data :: binary() }.
+split_command_into_components(Buffer) when is_binary(Buffer) ->
+ split_command(Buffer).
+
+-spec is_tagged_response(Buffer :: binary(), Tag :: binary()) -> tagged | untagged.
+is_tagged_response(Buffer, Tag) ->
+ TagSize = size(Tag) + 1, % The extra char is a space
+ BufferSize = size(Buffer),
+ case
+ case (TagSize =< BufferSize) of
+ true -> <<Tag/binary, " ">> =:= binary:part(Buffer, 0, TagSize);
+ _ -> false
+ end of
+
+ true -> tagged;
+ _ -> untagged
+ end.
+
+-spec num_literal_continuation_bytes(Buffer :: binary()) -> { BufferSansContinuation :: binary(), NumberBytes :: integer() }.
+num_literal_continuation_bytes(Buffer) when size(Buffer) < 4 ->
+ { Buffer, 0 };
+num_literal_continuation_bytes(Buffer) ->
+ case binary:last(Buffer) =:= $} of
+ true -> number_of_bytes_in_continuation(Buffer);
+ false -> { Buffer, 0 }
+ end.
+
+number_of_bytes_in_continuation(Buffer) ->
+ BufferSize = size(Buffer),
+ OpenBracePos = find_continuation_open_brace(Buffer, BufferSize - 3),
+ confirm_continuation(Buffer, OpenBracePos).
+
+find_continuation_open_brace(_Buffer, 0) -> -1;
+find_continuation_open_brace(Buffer, Pos) ->
+ case binary:at(Buffer, Pos) of
+ ${ -> Pos;
+ _ -> find_continuation_open_brace(Buffer, Pos - 1)
+ end.
+
+confirm_continuation(Buffer, -1) ->
+ { Buffer, 0 };
+confirm_continuation(Buffer, OpenBracePos) ->
+ BufferSize = size(Buffer),
+ % Strip any '+' following the literal size (due to LITERAL+)
+ LiteralSize = case binary:at(Buffer, BufferSize - 2) of
+ $+ -> binary:part(Buffer, OpenBracePos + 1, BufferSize - OpenBracePos - 3);
+ _ -> binary:part(Buffer, OpenBracePos + 1, BufferSize - OpenBracePos - 2)
+ end,
+
+ try binary_to_integer(LiteralSize) of
+ Result -> { binary:part(Buffer, 0, OpenBracePos), Result }
+ catch
+ _:_ -> { Buffer, 0 }
+ end.
+
+-spec remove_tag_from_response(Buffer :: binary(), Tag :: undefine | binary(), Check :: check | trust) -> Command :: binary().
+remove_tag_from_response(Buffer, undefined, _) ->
+ Buffer;
+remove_tag_from_response(Buffer, <<>>, _) ->
+ Buffer;
+remove_tag_from_response(Buffer, Tag, check) ->
+ TagSize = size(Tag) + 1, % The extra char is a space
+ BufferSize = size(Buffer),
+ case TagSize =< BufferSize of
+ true ->
+ case <<Tag/binary, " ">> =:= binary:part(Buffer, 0, TagSize) of
+ true -> binary:part(Buffer, TagSize, BufferSize - TagSize);
+ false -> Buffer
+ end;
+ false -> Buffer
+ end;
+remove_tag_from_response(Buffer, Tag, trust) ->
+ TagSize = size(Tag) + 1, % The extra char is a space
+ BufferSize = size(Buffer),
+ case TagSize =< BufferSize of
+ true -> binary:part(Buffer, TagSize, BufferSize - TagSize);
+ false -> Buffer
+ end.
+
+%% Private
+split_command(<<>>) -> { <<>>, <<>>, <<>> };
+split_command(Buffer) ->
+ {Terminated, End} = eol_found(Buffer, binary:match(Buffer, <<"\r\n">>)),
+ { Tag, CommandStart } = searched_in_buffer(Buffer, 0, End, binary:match(Buffer, <<" ">>, [ { scope, { 0, End } } ])),
+ case Terminated of
+ true when End == CommandStart ->
+ %% when we have a newline, and the tag takes the entire line, the "tag" is actually the command
+ {<<>>, Tag, <<>>};
+ _ ->
+ { Command, DataStart } = searched_in_buffer(Buffer, CommandStart, End, binary:match(Buffer, <<" ">>, [ { scope, { CommandStart, End - CommandStart } } ])),
+ Data = binary:part(Buffer, DataStart, End - (DataStart)),
+ { Tag, Command, Data }
+ end.
+
+eol_found(Buffer, nomatch) -> {false, size(Buffer)};
+eol_found(_Buffer, { MatchStart, _MatchLength }) -> {true, MatchStart}.
+
+searched_in_buffer(Buffer, Start, End, nomatch) -> { binary:part(Buffer, Start, End - Start), End };
+searched_in_buffer(Buffer, Start, _End, { MatchStart, MatchLength } ) -> { binary:part(Buffer, Start, MatchStart - Start), MatchStart + MatchLength }.
+
+is_no_token_found(Data, Tag, nomatch) ->
+ BadToken = <<Tag/binary, " BAD ">>,
+ BadTokenLength = byte_size(BadToken),
+ Match = binary:match(Data, BadToken, [ { scope, { 0, BadTokenLength } } ]),
+ is_bad_token_found(Data, Tag, Match);
+is_no_token_found(Data, _Tag, { Start, Length }) ->
+ ReasonStart = Start + Length,
+ Reason = binary:part(Data, ReasonStart, byte_size(Data) - ReasonStart),
+ { no, chop_newlines(Reason) }.
+
+is_bad_token_found(_Data, _Tag, nomatch) ->
+ ok;
+is_bad_token_found(Data, _Tag, { Start, Length }) ->
+ ReasonStart = Start + Length,
+ %% -2 is due to the traling \r\n
+ Reason = binary:part(Data, ReasonStart, byte_size(Data) - ReasonStart),
+ { bad, chop_newlines(Reason) }.
+
+chop_newlines(Data) ->
+ Size = size(Data),
+ chop_newline(Data, binary:at(Data, Size - 1), Size - 1).
+
+chop_newline(Data, $\r, Size) -> chop_newline(Data, binary:at(Data, Size - 1), Size - 1);
+chop_newline(Data, $\n, Size) -> chop_newline(Data, binary:at(Data, Size - 1), Size - 1);
+chop_newline(Data, _, Size) -> binary_part(Data, 0, Size + 1).
+
+imap_folder_path_from_parts(none, _HierarchyDelim, [], _Domain, Path) ->
+ Path;
+imap_folder_path_from_parts(SharedPrefix, _HierarchyDelim, [], _Domain, Path) ->
+ case string:str(Path, SharedPrefix) of
+ 1 -> string:substr(Path, length(SharedPrefix) + 1);
+ _ -> Path
+ end;
+imap_folder_path_from_parts(_SharedPrefix, HierarchyDelim, User, Domain, "INBOX") ->
+ string:join(["user", string:join([User, Domain], "@")], HierarchyDelim);
+imap_folder_path_from_parts(_SharedPrefix, HierarchyDelim, User , Domain, Path) ->
+ string:join(["user", User, string:join([Path, Domain], "@")], HierarchyDelim).
+
+imap_folder_path(_SharedPrefix, _HierarchyDelim, { error, Reason }) ->
+ lager:info("ERROR! ~p", [Reason]),
+ bad_uri;
+imap_folder_path(SharedPrefix, HierarchyDelim, { ok, {_Scheme, User, Domain, _Port, FullPath, _Query} }) ->
+ { VDomain, _ImapHost } = split_imap_uri_domain(string:tokens(Domain, "@")),
+ [ [_|Path] | _ ] = string:tokens(FullPath, ";"),
+ %%lager:info("PARSED IMAP URI: ~p ~p ~p", [User, VDomain, Path]),
+ CanonicalPath = imap_folder_path_from_parts(SharedPrefix, HierarchyDelim, User, VDomain, http_uri:decode(Path)),
+ %%lager:info("PUT TOGETHER AS: ~p", [CanonicalPath]),
+ CanonicalPath.
+
+split_imap_uri_domain([ ImapHost ]) -> { ImapHost, ImapHost };
+split_imap_uri_domain([ VDomain, ImapHost ]) -> { VDomain, ImapHost }.
+
+ensure_binary(Arg) when is_list(Arg) -> list_to_binary(Arg);
+ensure_binary(Arg) when is_binary(Arg) -> Arg;
+ensure_binary(Arg) when is_atom(Arg) -> atom_to_binary(Arg, latin1);
+ensure_binary(_Arg) -> <<>>.
+
+new_imap_compressors() ->
+ Inflator = zlib:open(),
+ ok = zlib:inflateInit(Inflator, -15),
+ Deflator = zlib:open(),
+ ok = zlib:deflateInit(Deflator, 1, deflated, -15, 8, default),
+ { Inflator, Deflator }.
+
+-spec only_full_lines(Buffer :: binary()) -> { BufferOfFullLines :: binary(), TrailingFragmentaryLine :: binary() }.
+only_full_lines(Buffer) ->
+ BufferLength = size(Buffer),
+ only_full_lines(Buffer, BufferLength, binary:at(Buffer, BufferLength - 1), BufferLength).
+
+only_full_lines(Buffer, BufferLength, $\n, Pos) when Pos =:= BufferLength -> { Buffer, <<>> };
+only_full_lines(Buffer, BufferLength, $\n, Pos) -> { binary:part(Buffer, 0, Pos + 1), binary:part(Buffer, Pos + 1, BufferLength - Pos - 1) };
+only_full_lines(Buffer, _BufferLength, _, 0) -> { <<>>, Buffer };
+only_full_lines(Buffer, BufferLength, _, Pos) -> only_full_lines(Buffer, BufferLength, binary:at(Buffer, Pos - 1), Pos - 1).
+
+-spec binary_to_atom(Value :: binary()) -> ValueAsAtom :: atom().
+binary_to_atom(Value) -> list_to_atom(string:to_lower(binary_to_list(Value))).

guam-0.9.11.tar.gz/_checkouts/eimap/test Added

guam-0.9.11.tar.gz/_checkouts/eimap/test/eimap_command_annotation_tests.erl Added

@@ -0,0 +1,71 @@
+%% Copyright 2014 Kolab Systems AG (http://www.kolabsys.com)
+%%
+%% Aaron Seigo (Kolab Systems) <seigo a kolabsys.com>
+%%
+%% This program is free software: you can redistribute it and/or modify
+%% it under the terms of the GNU Library 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 Library General Public License for more details.
+%%
+%% You should have received a copy of the GNU Library General Public License
+%% along with this program. If not, see <http://www.gnu.org/licenses/>.
+
+-module(eimap_command_annotation_tests).
+-include_lib("eunit/include/eunit.hrl").
+
+% c("test/eimap_command_annotation_tests.erl"). eunit:test(eimap_command_annotation).
+
+parse_test_() ->
+ Data =
+ [
+ %% { tag, server_response, expected_parsed_results }
+ {
+ <<"EG0002">>,
+ <<"* ANNOTATION \"user/john.doe/Calendar/Personal Calendar@example.org\" \"/vendor/kolab/color\" (\"value.shared\" \"32CD32\")\r\n * ANNOTATION \"user/john.doe/Calendar/Personal Calendar@example.org\" \"/vendor/kolab/folder-type\" (\"value.shared\" \"event\")\r\n * ANNOTATION \"user/john.doe/Calendar/Personal Calendar@example.org\" \"/vendor/x-toltec/test\" (\"value.shared\" NIL)\r\n * ANNOTATION \"user/john.doe/Calendar/Personal Calendar@example.org\" \"/vendor/horde/share-params\" (\"value.shared\" NIL)\r\n * ANNOTATION \"user/john.doe/Calendar/Personal Calendar@example.org\" \"/vendor/kolab/h-share-attr-desc\" (\"value.shared\" NIL)\r\n * ANNOTATION \"user/john.doe/Calendar/Personal Calendar@example.org\" \"/vendor/kolab/uniqueid\" (\"value.shared\" NIL)\r\n * ANNOTATION \"user/john.doe/Calendar/Personal Calendar@example.org\" \"/vendor/kolab/pxfb-readable-for\" (\"value.shared\" NIL)\r\n * ANNOTATION \"user/john.doe/Calendar/Personal Calendar@example.org\" \"/vendor/kolab/incidences-for\" (\"value.shared\" NIL)\r\n * ANNOTATION \"user/john.doe/Calendar/Personal Calendar@example.org\" \"/vendor/kolab/folder-test\" (\"value.shared\" NIL)\r\n * ANNOTATION \"user/john.doe/Calendar/Personal Calendar@example.org\" \"/vendor/kolab/displayname\" (\"value.shared\" NIL)\r\n * ANNOTATION \"user/john.doe/Calendar/Personal Calendar@example.org\" \"/vendor/kolab/activesync\" (\"value.shared\" NIL)\r\n * ANNOTATION \"user/john.doe/Calendar/Personal Calendar@example.org\" \"/vendor/cmu/cyrus-imapd/uniqueid\" (\"value.shared\" \"b1a5bb95-2bd3-4628-a0d2-49e9bd10735e\")\r\n * ANNOTATION \"user/john.doe/Calendar/Personal Calendar@example.org\" \"/vendor/cmu/cyrus-imapd/squat\" (\"value.shared\" NIL)\r\n * ANNOTATION \"user/john.doe/Calendar/Personal Calendar@example.org\" \"/vendor/cmu/cyrus-imapd/size\" (\"value.shared\" \"5726\")\r\n * ANNOTATION \"user/john.doe/Calendar/Personal Calendar@example.org\" \"/vendor/cmu/cyrus-imapd/sieve\" (\"value.shared\" NIL)\r\n * ANNOTATION \"user/john.doe/Calendar/Personal Calendar@example.org\" \"/vendor/cmu/cyrus-imapd/sharedseen\" (\"value.shared\" \"false\")\r\n * ANNOTATION \"user/john.doe/Calendar/Personal Calendar@example.org\" \"/vendor/cmu/cyrus-imapd/pop3showafter\" (\"value.shared\" NIL)\r\n * ANNOTATION \"user/john.doe/Calendar/Personal Calendar@example.org\" \"/vendor/cmu/cyrus-imapd/pop3newuidl\" (\"value.shared\" \"true\")\r\n * ANNOTATION \"user/john.doe/Calendar/Personal Calendar@example.org\" \"/vendor/cmu/cyrus-imapd/partition\" (\"value.shared\" \"default\")\r\n * ANNOTATION \"user/john.doe/Calendar/Personal Calendar@example.org\" \"/vendor/cmu/cyrus-imapd/news2mail\" (\"value.shared\" NIL)\r\n * ANNOTATION \"user/john.doe/Calendar/Personal Calendar@example.org\" \"/vendor/cmu/cyrus-imapd/lastupdate\" (\"value.shared\" \"20-Mar-2015 05:17:51 +0100\")\r\n * ANNOTATION \"user/john.doe/Calendar/Personal Calendar@example.org\" \"/vendor/cmu/cyrus-imapd/lastpop\" (\"value.shared\" NIL)\r\n * ANNOTATION \"user/john.doe/Calendar/Personal Calendar@example.org\" \"/vendor/cmu/cyrus-imapd/expire\" (\"value.shared\" NIL)\r\n * ANNOTATION \"user/john.doe/Calendar/Personal Calendar@example.org\" \"/vendor/cmu/cyrus-imapd/duplicatedeliver\" (\"value.shared\" \"false\")\r\n * ANNOTATION \"user/john.doe/Calendar/Personal Calendar@example.org\" \"/thread\" (\"value.shared\" NIL)\r\n * ANNOTATION \"user/john.doe/Calendar/Personal Calendar@example.org\" \"/specialuse\" (\"value.shared\" NIL)\r\n * ANNOTATION \"user/john.doe/Calendar/Personal Calendar@example.org\" \"/sort\" (\"value.shared\" NIL)\r\n * ANNOTATION \"user/john.doe/Calendar/Personal Calendar@example.org\" \"/comment\" (\"value.shared\" NIL)\r\n * ANNOTATION \"user/john.doe/Calendar/Personal Calendar@example.org\" \"/checkperiod\" (\"value.shared\" NIL)\r\n * ANNOTATION \"user/john.doe/Calendar/Personal Calendar@example.org\" \"/check\" (\"value.shared\" NIL)\r\nEG0002 OK Completed\r\n">>,
+ { fini, [
+ {<<"/vendor/cmu/cyrus-imapd/duplicatedeliver">>, false},
+ {<<"/vendor/cmu/cyrus-imapd/lastupdate">>, <<"20-Mar-2015 05:17:51 +0100">>},
+ {<<"/vendor/cmu/cyrus-imapd/partition">>,<<"default">>},
+ {<<"/vendor/cmu/cyrus-imapd/pop3newuidl">>,true},
+ {<<"/vendor/cmu/cyrus-imapd/sharedseen">>,false},
+ {<<"/vendor/cmu/cyrus-imapd/size">>,5726},
+ {<<"/vendor/cmu/cyrus-imapd/uniqueid">>, <<"b1a5bb95-2bd3-4628-a0d2-49e9bd10735e">>},
+ {<<"/vendor/kolab/folder-type">>,<<"event">>},
+ {<<"/vendor/kolab/color">>,<<"32CD32">>}
+ ]
+ }
+ },
+ {
+ <<"EG0002">>,
+ <<"* ANNOTATION user/john.doe/Sent@example.org \"/vendor/x-toltec/test\" (\"value.shared\" NIL)\r\n * ANNOTATION user/john.doe/Sent@example.org \"/vendor/horde/share-params\" (\"value.shared\" NIL)\r\n * ANNOTATION user/john.doe/Sent@example.org \"/vendor/kolab/h-share-attr-desc\" (\"value.shared\" NIL)\r\n * ANNOTATION user/john.doe/Sent@example.org \"/vendor/kolab/uniqueid\" (\"value.shared\" NIL)\r\n * ANNOTATION user/john.doe/Sent@example.org \"/vendor/kolab/pxfb-readable-for\" (\"value.shared\" NIL)\r\n * ANNOTATION user/john.doe/Sent@example.org \"/vendor/kolab/incidences-for\" (\"value.shared\" NIL)\r\n * ANNOTATION user/john.doe/Sent@example.org \"/vendor/kolab/folder-type\" (\"value.shared\" NIL)\r\n * ANNOTATION user/john.doe/Sent@example.org \"/vendor/kolab/folder-test\" (\"value.shared\" NIL)\r\n * ANNOTATION user/john.doe/Sent@example.org \"/vendor/kolab/displayname\" (\"value.shared\" NIL)\r\n * ANNOTATION user/john.doe/Sent@example.org \"/vendor/kolab/color\" (\"value.shared\" NIL)\r\n * ANNOTATION user/john.doe/Sent@example.org \"/vendor/kolab/activesync\" (\"value.shared\" NIL)\r\n * ANNOTATION user/john.doe/Sent@example.org \"/vendor/cmu/cyrus-imapd/uniqueid\" (\"value.shared\" \"237357ec-7610-422e-9e55-0bae83caf58a\")\r\n * ANNOTATION user/john.doe/Sent@example.org \"/vendor/cmu/cyrus-imapd/squat\" (\"value.shared\" NIL)\r\n * ANNOTATION user/john.doe/Sent@example.org \"/vendor/cmu/cyrus-imapd/size\" (\"value.shared\" \"401\")\r\n * ANNOTATION user/john.doe/Sent@example.org \"/vendor/cmu/cyrus-imapd/sieve\" (\"value.shared\" NIL)\r\n * ANNOTATION user/john.doe/Sent@example.org \"/vendor/cmu/cyrus-imapd/sharedseen\" (\"value.shared\" \"false\")\r\n * ANNOTATION user/john.doe/Sent@example.org \"/vendor/cmu/cyrus-imapd/pop3showafter\" (\"value.shared\" NIL)\r\n * ANNOTATION user/john.doe/Sent@example.org \"/vendor/cmu/cyrus-imapd/pop3newuidl\" (\"value.shared\" \"true\")\r\n * ANNOTATION user/john.doe/Sent@example.org \"/vendor/cmu/cyrus-imapd/partition\" (\"value.shared\" \"default\")\r\n * ANNOTATION user/john.doe/Sent@example.org \"/vendor/cmu/cyrus-imapd/news2mail\" (\"value.shared\" NIL)\r\n * ANNOTATION user/john.doe/Sent@example.org \"/vendor/cmu/cyrus-imapd/lastupdate\" (\"value.shared\" \"23-Mar-2015 15:19:29 +0100\")\r\n * ANNOTATION user/john.doe/Sent@example.org \"/vendor/cmu/cyrus-imapd/lastpop\" (\"value.shared\" NIL)\r\n * ANNOTATION user/john.doe/Sent@example.org \"/vendor/cmu/cyrus-imapd/expire\" (\"value.shared\" NIL)\r\n * ANNOTATION user/john.doe/Sent@example.org \"/vendor/cmu/cyrus-imapd/duplicatedeliver\" (\"value.shared\" \"false\")\r\n * ANNOTATION user/john.doe/Sent@example.org \"/thread\" (\"value.shared\" NIL)\r\n * ANNOTATION user/john.doe/Sent@example.org \"/specialuse\" (\"value.shared\" NIL)\r\n * ANNOTATION user/john.doe/Sent@example.org \"/sort\" (\"value.shared\" NIL)\r\n * ANNOTATION user/john.doe/Sent@example.org \"/comment\" (\"value.shared\" NIL)\r\n * ANNOTATION user/john.doe/Sent@example.org \"/checkperiod\" (\"value.shared\" NIL)\r\n * ANNOTATION user/john.doe/Sent@example.org \"/check\" (\"value.shared\" NIL)\r\nEG0002 OK Completed\r\n">>,
+ { fini, [
+ {<<"/vendor/cmu/cyrus-imapd/duplicatedeliver">>,false},
+ {<<"/vendor/cmu/cyrus-imapd/lastupdate">>,<<"23-Mar-2015 15:19:29 +0100">>},
+ {<<"/vendor/cmu/cyrus-imapd/partition">>,<<"default">>},
+ {<<"/vendor/cmu/cyrus-imapd/pop3newuidl">>,true},
+ {<<"/vendor/cmu/cyrus-imapd/sharedseen">>,false},
+ {<<"/vendor/cmu/cyrus-imapd/size">>,401},
+ {<<"/vendor/cmu/cyrus-imapd/uniqueid">>,<<"237357ec-7610-422e-9e55-0bae83caf58a">>}
+ ]
+ }
+ }
+ ],
+ { _Command, ResponseType } = eimap_command_annotation:new_command(<<"/my/folder">>),
+ lists:foldl(fun({ Tag, ServerData, Expected }, Acc) -> [?_assertEqual(Expected, eimap_command:parse_response(ResponseType, ServerData, Tag, eimap_command_annotation))|Acc] end, [], Data).
+
+new_test_() ->
+ Data =
+ [
+ %% mailbox, command
+ {
+ <<"user/john.doe/Calendar/Personal Calendar@example.org">>,
+ { <<"GETANNOTATION \"user/john.doe/Calendar/Personal Calendar@example.org\" \"*\" \"value.shared\"">>, multiline_response }
+ }
+ ],
+ lists:foldl(fun({ Mailbox, Command }, Acc) -> [?_assertEqual(Command, eimap_command_annotation:new_command(Mailbox))|Acc] end, [], Data).
+

guam-0.9.11.tar.gz/_checkouts/eimap/test/eimap_command_capability_tests.erl Added

@@ -0,0 +1,70 @@
+%% Copyright 2014 Kolab Systems AG (http://www.kolabsys.com)
+%%
+%% Aaron Seigo (Kolab Systems) <seigo a kolabsys.com>
+%%
+%% This program is free software: you can redistribute it and/or modify
+%% it under the terms of the GNU Library 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 Library General Public License for more details.
+%%
+%% You should have received a copy of the GNU Library General Public License
+%% along with this program. If not, see <http://www.gnu.org/licenses/>.
+
+-module(eimap_command_capability_tests).
+-include_lib("eunit/include/eunit.hrl").
+
+parse_test_() ->
+ Data =
+ [
+ % { Binary Response, Binary Tag, Parsed Results }
+ {
+ parse_serverid,
+ <<"* OK [CAPABILITY IMAP4rev1 LITERAL+ ID ENABLE STARTTLS LOGINDISABLED] acme.com Cyrus IMAP 2.5.5.5-Kolab-2.5.5-5.1.el6.kolab_14 server ready\r\n">>,
+ <<>>,
+ { fini, { <<"IMAP4rev1 LITERAL+ ID ENABLE STARTTLS LOGINDISABLED">>, <<"acme.com Cyrus IMAP 2.5.5.5-Kolab-2.5.5-5.1.el6.kolab_14 server ready">> } }
+ },
+ {
+ ok,
+ <<"* CAPABILITY IMAP4rev1 LITERAL+ ID ENABLE STARTTLS AUTH=PLAIN AUTH=LOGIN SASL-IR\r\nabcd OK CAPABILITY COMPLETED\r\n">>,
+ <<"abcd">>,
+ { fini, [<<"IMAP4rev1 LITERAL+ ID ENABLE STARTTLS AUTH=PLAIN AUTH=LOGIN SASL-IR">>] }
+ },
+ {
+ ok,
+ <<"other stuff\r\n">>,
+ <<"abcd">>,
+ { more, { <<>>, [], eimap_command_capability } }
+ },
+ {
+ ok,
+ <<"abcd BAD Uh uh uh\r\n">>,
+ <<"abcd">>,
+ { error, <<"Uh uh uh">> }
+ },
+ {
+ ok,
+ <<"abcd NO Uh uh uh\r\n">>,
+ <<"abcd">>,
+ { error, <<"Uh uh uh">> }
+ }
+ ],
+ lists:foldl(fun({ InitArgs, Response, Tag, Parsed }, Acc) ->
+ { _Command, ResponseType } = eimap_command_capability:new_command(InitArgs),
+ [?_assertEqual(Parsed, eimap_command:parse_response(ResponseType, Response, Tag, eimap_command_capability))|Acc] end, [], Data).
+
+new_test_() ->
+ Data =
+ [
+ % input, output
+ { parse_serverid, { <<"CAPABILITY">>, single_line_response } },
+ { <<>>, { <<"CAPABILITY">>, multiline_response } },
+ { true, { <<"CAPABILITY">>, multiline_response } },
+ { [], { <<"CAPABILITY">>, multiline_response } }
+ ],
+ lists:foldl(fun({ Params, Command }, Acc) -> [?_assertEqual(Command, eimap_command_capability:new_command(Params))|Acc] end, [], Data).
+

guam-0.9.11.tar.gz/_checkouts/eimap/test/eimap_command_compress_tests.erl Added

@@ -0,0 +1,55 @@
+%% Copyright 2014 Kolab Systems AG (http://www.kolabsys.com)
+%%
+%% Aaron Seigo (Kolab Systems) <seigo a kolabsys.com>
+%%
+%% This program is free software: you can redistribute it and/or modify
+%% it under the terms of the GNU Library 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 Library General Public License for more details.
+%%
+%% You should have received a copy of the GNU Library General Public License
+%% along with this program. If not, see <http://www.gnu.org/licenses/>.
+
+-module(eimap_command_compress_tests).
+-include_lib("eunit/include/eunit.hrl").
+
+parse_test_() ->
+ Data =
+ [
+ % { Binary Response, Binary Tag, Parsed Results }
+ {
+ <<"abcd OK DEFLATE active\r\n">>,
+ <<"abcd">>,
+ compression_active
+ },
+ {
+ <<"abcd BAD Uh uh uh\r\n">>,
+ <<"abcd">>,
+ { error, <<"Uh uh uh">> }
+ },
+ {
+ <<"abcd NO Uh uh uh\r\n">>,
+ <<"abcd">>,
+ { error, <<"Uh uh uh">> }
+ }
+ ],
+ InitArgs = ok,
+ { _Command, ResponseType } = eimap_command_compress:new_command(InitArgs),
+ lists:foldl(fun({ Response, Tag, Parsed }, Acc) -> [?_assertEqual(Parsed, eimap_command:parse_response(ResponseType, Response, Tag, eimap_command_compress))|Acc] end, [], Data).
+
+new_test_() ->
+ Data =
+ [
+ % input, output
+ { ok, { <<"COMPRESS DEFLATE">>, single_line_response } },
+ { <<>>, { <<"COMPRESS DEFLATE">>, single_line_response } },
+ { true, { <<"COMPRESS DEFLATE">>, single_line_response } },
+ { [], { <<"COMPRESS DEFLATE">>, single_line_response } }
+ ],
+ lists:foldl(fun({ Params, Command }, Acc) -> [?_assertEqual(Command, eimap_command_compress:new_command(Params))|Acc] end, [], Data).
+

guam-0.9.11.tar.gz/_checkouts/eimap/test/eimap_command_getmetadata_tests.erl Added

@@ -0,0 +1,83 @@
+%% Copyright 2014 Kolab Systems AG (http://www.kolabsys.com)
+%%
+%% Aaron Seigo (Kolab Systems) <seigo a kolabsys.com>
+%%
+%% This program is free software: you can redistribute it and/or modify
+%% it under the terms of the GNU Library 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 Library General Public License for more details.
+%%
+%% You should have received a copy of the GNU Library General Public License
+%% along with this program. If not, see <http://www.gnu.org/licenses/>.
+
+-module(eimap_command_getmetadata_tests).
+-include_lib("eunit/include/eunit.hrl").
+
+parse_test_() ->
+ Data =
+ [
+ % { Binary Response, Binary Tag, Parsed Results }
+ {
+ <<"* METADATA Tasks (/shared/vendor/kolab/folder-type \"task\")\r\nabcd OK Begin TLS negotiation now\r\n">>,
+ <<"abcd">>,
+ { fini, [ { <<"Tasks">>, [ { <<"/shared/vendor/kolab/folder-type">>, <<"task">> } ] } ] }
+ },
+ {
+ <<"* METADATA \"Tasks Tasks\" (/shared/vendor/kolab/folder-type \"task\")\r\nabcd OK Begin TLS negotiation now\r\n">>,
+ <<"abcd">>,
+ { fini, [ { <<"Tasks Tasks">>, [ { <<"/shared/vendor/kolab/folder-type">>, <<"task">> } ] } ] }
+ },
+ {
+ <<"* METADATA Tasks (/shared/vendor/kolab/folder-type \"task \\\"sigh\\\"\")\r\nabcd OK Begin TLS negotiation now\r\n">>,
+ <<"abcd">>,
+ { fini, [ { <<"Tasks">>, [ { <<"/shared/vendor/kolab/folder-type">>, <<"task \"sigh\"">> } ] } ] }
+ },
+ {
+ <<"* METADATA Tasks (/shared/vendor/kolab/folder-type \"task \\\"sigh\\\"\" /private/comment \"My own comment\")\r\nabcd OK Begin TLS negotiation now\r\n">>,
+ <<"abcd">>,
+ { fini, [ { <<"Tasks">>, [ { <<"/private/comment">>, <<"My own comment">> }, { <<"/shared/vendor/kolab/folder-type">>, <<"task \"sigh\"">> } ] } ] }
+ },
+ {
+ <<"* METADATA Tasks (/shared/vendor/kolab/folder-type \"task \\\"sigh\\\"\")\r\n* METADATA Archive (/shared/vendor/kolab/folder-type NIL)\r\nabcd OK Begin TLS negotiation now\r\n">>,
+ <<"abcd">>,
+ { fini, [
+ { <<"Archive">>, [ {<<"/shared/vendor/kolab/folder-type">>, null } ] },
+ { <<"Tasks">>, [ { <<"/shared/vendor/kolab/folder-type">>, <<"task \"sigh\"">> } ] }
+ ]
+ }
+ },
+ {
+ <<"abcd BAD Uh uh uh\r\n">>,
+ <<"abcd">>,
+ { error, <<"Uh uh uh">> }
+ },
+ {
+ <<"abcd NO Uh uh uh\r\n">>,
+ <<"abcd">>,
+ { error, <<"Uh uh uh">> }
+ }
+ ],
+ lists:foldl(fun({ Response, Tag, Parsed }, Acc) ->
+ [?_assertEqual(Parsed, eimap_command:parse_response(multiline_response, Response, Tag, eimap_command_getmetadata))|Acc] end, [], Data).
+
+new_test_() ->
+ Data =
+ [
+ % input, output
+ { { <<>> }, { <<"GETMETADATA (DEPTH infinity) \"\"">>, multiline_response } },
+ { { <<>>, [<<"/shared/comment">>, "/private/comment"] }, { <<"GETMETADATA (DEPTH infinity) \"\" (/shared/comment /private/comment)">>, multiline_response } },
+ { { <<"/my/folder">>, [<<"/shared/comment">>, "/private/comment"] }, { <<"GETMETADATA (DEPTH infinity) \"/my/folder\" (/shared/comment /private/comment)">>, multiline_response } },
+ { { "/my/folder", [<<"/shared/comment">>, "/private/comment"] }, { <<"GETMETADATA (DEPTH infinity) \"/my/folder\" (/shared/comment /private/comment)">>, multiline_response } },
+ { { <<"/my/folder">> }, { <<"GETMETADATA (DEPTH infinity) \"/my/folder\"">>, multiline_response } },
+ { { "/my/folder", [], 10, 100 }, { <<"GETMETADATA (DEPTH 10 MAXSIZE 100) \"/my/folder\"">>, multiline_response } },
+ { { <<"/my/folder">>, [], 10, 100 }, { <<"GETMETADATA (DEPTH 10 MAXSIZE 100) \"/my/folder\"">>, multiline_response } },
+ { { <<"/my/folder">>, [], 10, none}, { <<"GETMETADATA (DEPTH 10) \"/my/folder\"">>, multiline_response } },
+ { { <<"/my/folder">>, [], none, 100 }, { <<"GETMETADATA (MAXSIZE 100) \"/my/folder\"">>, multiline_response } }
+ ],
+ lists:foldl(fun({ Params, Command }, Acc) -> [?_assertEqual(Command, eimap_command_getmetadata:new_command(Params))|Acc] end, [], Data).
+

guam-0.9.11.tar.gz/_checkouts/eimap/test/eimap_command_login_tests.erl Added

@@ -0,0 +1,51 @@
+%% Copyright 2014 Kolab Systems AG (http://www.kolabsys.com)
+%%
+%% Aaron Seigo (Kolab Systems) <seigo a kolabsys.com>
+%%
+%% This program is free software: you can redistribute it and/or modify
+%% it under the terms of the GNU Library 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 Library General Public License for more details.
+%%
+%% You should have received a copy of the GNU Library General Public License
+%% along with this program. If not, see <http://www.gnu.org/licenses/>.
+
+-module(eimap_command_login_tests).
+-include_lib("eunit/include/eunit.hrl").
+
+parse_test_() ->
+ Data =
+ [
+ % { Binary Response, Binary Tag, Parsed Results }
+ {
+ <<"abcd OK LOGIN completed\r\n">>,
+ <<"abcd">>,
+ { fini, authed }
+ },
+ {
+ <<"abcd BAD Uh uh uh\r\n">>,
+ <<"abcd">>,
+ { error, <<"Uh uh uh">> }
+ },
+ {
+ <<"abcd NO Uh uh uh\r\n">>,
+ <<"abcd">>,
+ { error, <<"Uh uh uh">> }
+ }
+ ],
+ lists:foldl(fun({ Response, Tag, Parsed }, Acc) -> [?_assertEqual(Parsed, eimap_command:parse_response(multiline_response, Response, Tag, eimap_command_login))|Acc] end, [], Data).
+
+new_test_() ->
+ Data =
+ [
+ % input, output
+ { { <<"aseigo">>, <<"oohyeah">> }, { <<"LOGIN aseigo oohyeah">>, multiline_response } },
+ { { "aseigo", "oohyeah" }, { <<"LOGIN aseigo oohyeah">>, multiline_response } }
+ ],
+ lists:foldl(fun({ Params, Command }, Acc) -> [?_assertEqual(Command, eimap_command_login:new_command(Params))|Acc] end, [], Data).
+

guam-0.9.11.tar.gz/_checkouts/eimap/test/eimap_command_logout_tests.erl Added

@@ -0,0 +1,52 @@
+%% Copyright 2014 Kolab Systems AG (http://www.kolabsys.com)
+%%
+%% Aaron Seigo (Kolab Systems) <seigo a kolabsys.com>
+%%
+%% This program is free software: you can redistribute it and/or modify
+%% it under the terms of the GNU Library 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 Library General Public License for more details.
+%%
+%% You should have received a copy of the GNU Library General Public License
+%% along with this program. If not, see <http://www.gnu.org/licenses/>.
+
+-module(eimap_command_logout_tests).
+-include_lib("eunit/include/eunit.hrl").
+
+parse_test_() ->
+ Data =
+ [
+ % { Binary Response, Binary Tag, Parsed Results }
+ {
+ <<"abcd OK Begin TLS negotiation now\r\n">>,
+ <<"abcd">>,
+ { close_socket, ok }
+ },
+ {
+ <<"abcd BAD Uh uh uh\r\n">>,
+ <<"abcd">>,
+ { close_socket, { error, <<"Uh uh uh">> } }
+ },
+ {
+ <<"abcd NO Uh uh uh\r\n">>,
+ <<"abcd">>,
+ { close_socket, { error, <<"Uh uh uh">> } }
+ }
+ ],
+ lists:foldl(fun({ Response, Tag, Parsed }, Acc) -> [?_assertEqual(Parsed, eimap_command:parse_response(multiline_response, Response, Tag, eimap_command_logout))|Acc] end, [], Data).
+
+new_test_() ->
+ Data =
+ [
+ % input, output
+ { <<>>, { <<"LOGOUT">>, multiline_response } },
+ { true, { <<"LOGOUT">>, multiline_response } },
+ { [], { <<"LOGOUT">>, multiline_response } }
+ ],
+ lists:foldl(fun({ Params, Command }, Acc) -> [?_assertEqual(Command, eimap_command_logout:new_command(Params))|Acc] end, [], Data).
+

guam-0.9.11.tar.gz/_checkouts/eimap/test/eimap_command_namespace_tests.erl Added

@@ -0,0 +1,72 @@
+%% Copyright 2014 Kolab Systems AG (http://www.kolabsys.com)
+%%
+%% Aaron Seigo (Kolab Systems) <seigo a kolabsys.com>
+%%
+%% This program is free software: you can redistribute it and/or modify
+%% it under the terms of the GNU Library 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 Library General Public License for more details.
+%%
+%% You should have received a copy of the GNU Library General Public License
+%% along with this program. If not, see <http://www.gnu.org/licenses/>.
+
+-module(eimap_command_namespace_tests).
+-include_lib("eunit/include/eunit.hrl").
+
+parse_test_() ->
+ Data =
+ [
+ % { Binary Response, Binary Tag, Parsed Results }
+ {
+ <<"* NAMESPACE ((\"\" \"/\")) NIL NIL\r\nabcd OK NAMESPACE command completed\r\n">>,
+ <<"abcd">>,
+ { fini, { none, none } }
+ },
+% {
+% <<"* NAMESPACE NIL NIL ((\"\" \".\"))\r\nabcd OK NAMESPACE command completed\r\n">>,
+% <<"abcd">>,
+% namespace
+% },
+% {
+% <<"* NAMESPACE ((\"\" \"/\")) NIL ((\"Public Folders/\" \"/\"))\r\nabcd OK NAMESPACE command completed\r\n">>,
+% <<"abcd">>,
+% namespace
+% },
+% {
+% <<"* NAMESPACE ((\"\" \"/\")) ((\"~\" \"/\")) ((\"#shared/\" \"/\")\r\n(\"#public/\" \"/\")(\"#ftp/\" \"/\")(\"#news.\" \".\"))\r\nabcd OK NAMESPACE command completed\r\n">>,
+% <<"abcd">>,
+% namespace
+% },
+% {
+% <<"* NAMESPACE ((\"INBOX.\" \".\")) NIL NIL\r\nabcd OK NAMESPACE command completed\r\n">>,
+% <<"abcd">>,
+% namespace
+% },
+ {
+ <<"abcd BAD Uh uh uh\r\n">>,
+ <<"abcd">>,
+ { error, <<"Uh uh uh">> }
+ },
+ {
+ <<"abcd NO Uh uh uh\r\n">>,
+ <<"abcd">>,
+ { error, <<"Uh uh uh">> }
+ }
+ ],
+ lists:foldl(fun({ Response, Tag, Parsed }, Acc) -> [?_assertEqual(Parsed, eimap_command:parse_response(multiline_response, Response, Tag, eimap_command_namespace))|Acc] end, [], Data).
+
+new_test_() ->
+ Data =
+ [
+ % input, output
+ { <<>>, { <<"NAMESPACE">>, multiline_response } },
+ { true, { <<"NAMESPACE">>, multiline_response } },
+ { [], { <<"NAMESPACE">>, multiline_response } }
+ ],
+ lists:foldl(fun({ Params, Command }, Acc) -> [?_assertEqual(Command, eimap_command_namespace:new_command(Params))|Acc] end, [], Data).
+

guam-0.9.11.tar.gz/_checkouts/eimap/test/eimap_command_noop_tests.erl Added

@@ -0,0 +1,69 @@
+%% Copyright 2014 Kolab Systems AG (http://www.kolabsys.com)
+%%
+%% Aaron Seigo (Kolab Systems) <seigo a kolabsys.com>
+%%
+%% This program is free software: you can redistribute it and/or modify
+%% it under the terms of the GNU Library 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 Library General Public License for more details.
+%%
+%% You should have received a copy of the GNU Library General Public License
+%% along with this program. If not, see <http://www.gnu.org/licenses/>.
+
+-module(eimap_command_noop_tests).
+-include_lib("eunit/include/eunit.hrl").
+
+parse_test_() ->
+ Data =
+ [
+ % { Binary Response, Binary Tag, Parsed Results }
+ {
+ ok,
+ <<"* 100 EXISTS\r\n* 22 EXPUNGE\r\n* 14 FETCH (FLAGS (\\\\Answered \\\\Flagged \\\\Draft \\\\Deleted \\\\Seen))\r\n* 3 Recent\r\nabcd OK Completed\r\n">>,
+ <<"abcd">>,
+ { fini,
+ [
+ { recent, 3 },
+ { fetch, 14 },
+ { expunge, 22 },
+ { exists, 100 }
+ ]
+ }
+ },
+ {
+ ok,
+ <<"abcd OK Completed\r\n">>,
+ <<"abcd">>,
+ { fini, [] }
+ },
+ {
+ ok,
+ <<"abcd BAD Uh uh uh\r\n">>,
+ <<"abcd">>,
+ { error, <<"Uh uh uh">> }
+ },
+ {
+ ok,
+ <<"abcd NO Uh uh uh\r\n">>,
+ <<"abcd">>,
+ { error, <<"Uh uh uh">> }
+ }
+ ],
+ lists:foldl(fun({ InitArgs, ServerResponse, Tag, Parsed }, Acc) ->
+ { _Command, ResponseType } = eimap_command_noop:new_command(InitArgs),
+ [?_assertEqual(Parsed, eimap_command:parse_response(ResponseType, ServerResponse, Tag, eimap_command_noop))|Acc] end, [], Data).
+
+new_test_() ->
+ Data =
+ [
+ % input, output
+ { ok, { <<"NOOP">>, multiline_response } },
+ { <<>>, { <<"NOOP">>, multiline_response } }
+ ],
+ lists:foldl(fun({ Params, Command }, Acc) -> [?_assertEqual(Command, eimap_command_noop:new_command(Params))|Acc] end, [], Data).
+

guam-0.9.11.tar.gz/_checkouts/eimap/test/eimap_command_starttls_tests.erl Added

@@ -0,0 +1,52 @@
+%% Copyright 2014 Kolab Systems AG (http://www.kolabsys.com)
+%%
+%% Aaron Seigo (Kolab Systems) <seigo a kolabsys.com>
+%%
+%% This program is free software: you can redistribute it and/or modify
+%% it under the terms of the GNU Library 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 Library General Public License for more details.
+%%
+%% You should have received a copy of the GNU Library General Public License
+%% along with this program. If not, see <http://www.gnu.org/licenses/>.
+
+-module(eimap_command_starttls_tests).
+-include_lib("eunit/include/eunit.hrl").
+
+parse_test_() ->
+ Data =
+ [
+ % { Binary Response, Binary Tag, Parsed Results }
+ {
+ <<"abcd OK Begin TLS negotiation now\r\n">>,
+ <<"abcd">>,
+ starttls
+ },
+ {
+ <<"abcd BAD Uh uh uh\r\n">>,
+ <<"abcd">>,
+ { error, <<"Uh uh uh">> }
+ },
+ {
+ <<"abcd NO Uh uh uh\r\n">>,
+ <<"abcd">>,
+ { error, <<"Uh uh uh">> }
+ }
+ ],
+ lists:foldl(fun({ Response, Tag, Parsed }, Acc) -> [?_assertEqual(Parsed, eimap_command:parse_response(single_line_response, Response, Tag, eimap_command_starttls))|Acc] end, [], Data).
+
+new_test_() ->
+ Data =
+ [
+ % input, output
+ { <<>>, { <<"STARTTLS">>, single_line_response } },
+ { true, { <<"STARTTLS">>, single_line_response } },
+ { [], { <<"STARTTLS">>, single_line_response } }
+ ],
+ lists:foldl(fun({ Params, Command }, Acc) -> [?_assertEqual(Command, eimap_command_starttls:new_command(Params))|Acc] end, [], Data).
+

guam-0.9.11.tar.gz/_checkouts/eimap/test/eimap_command_status_tests.erl Added

@@ -0,0 +1,65 @@
+%% Copyright 2014 Kolab Systems AG (http://www.kolabsys.com)
+%%
+%% Aaron Seigo (Kolab Systems) <seigo a kolabsys.com>
+%%
+%% This program is free software: you can redistribute it and/or modify
+%% it under the terms of the GNU Library 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 Library General Public License for more details.
+%%
+%% You should have received a copy of the GNU Library General Public License
+%% along with this program. If not, see <http://www.gnu.org/licenses/>.
+
+-module(eimap_command_status_tests).
+-include_lib("eunit/include/eunit.hrl").
+
+parse_test_() ->
+ Data =
+ [
+ % { Binary Response, Binary Tag, Parsed Results }
+ {
+ <<"* STATUS blurdybloop (MESSAGES 231 UIDNEXT 44292)\r\nabcd OK Begin TLS negotiation now\r\n">>,
+ <<"abcd">>,
+ { fini, [{ uidnext, 44292 }, { messages, 231 }] }
+ },
+ {
+ <<"* STATUS blurdybloop (MESSAGES 231 UIDNEXT 44292 RECENT 0 UIDVALIDITY 10110 UNSEEN 10)\r\nabcd OK Begin TLS negotiation now\r\n">>,
+ <<"abcd">>,
+ { fini, [{ unseen, 10 }, { uidvalidity, 10110 }, { recent, 0 }, { uidnext, 44292 }, { messages, 231 }] }
+ },
+ {
+ <<"* STATUS blurdybloop (RECENT 1 UIDVALIDITY 44292)\r\nabcd OK Begin TLS negotiation now\r\n">>,
+ <<"abcd">>,
+ { fini, [{ uidvalidity, 44292 }, { recent, 1 }] }
+ }
+ ],
+ lists:foldl(fun({ Response, Tag, Parsed }, Acc) -> [?_assertEqual(Parsed, eimap_command:parse_response(multiline_response, Response, Tag, eimap_command_status))|Acc] end, [], Data).
+
+new_test_() ->
+ Data =
+ [
+ % input, output
+ { { "INBOX", [] },
+ { <<"STATUS INBOX (MESSAGES)">>, multiline_response } },
+ { { <<"INBOX">>, [] },
+ { <<"STATUS INBOX (MESSAGES)">>, multiline_response } },
+ { { <<>>, [messages] },
+ { <<"STATUS INBOX (MESSAGES)">>, multiline_response } },
+ { { <<"">>, [messages] },
+ { <<"STATUS INBOX (MESSAGES)">>, multiline_response } },
+ { { <<"/my/folder">>, [messages, recent, uidnext, uidvalidity, unseen] },
+ { <<"STATUS /my/folder (MESSAGES RECENT UIDNEXT UIDVALIDITY UNSEEN)">>, multiline_response } },
+ { { <<"/my/folder">>, [uidnext, recent, uidvalidity, unseen] },
+ { <<"STATUS /my/folder (UIDNEXT RECENT UIDVALIDITY UNSEEN)">>, multiline_response } },
+ { { <<"/my/folder">>, [garbage, unseen] },
+ { <<"STATUS /my/folder (UNSEEN)">>, multiline_response } },
+ { { <<"/my/folder">>, [garbage] },
+ { <<"STATUS /my/folder (MESSAGES)">>, multiline_response } }
+ ],
+ lists:foldl(fun({ Params, Command }, Acc) -> [?_assertEqual(Command, eimap_command_status:new_command(Params))|Acc] end, [], Data).
+

guam-0.9.11.tar.gz/_checkouts/eimap/test/eimap_command_switch_folder_tests.erl Added

@@ -0,0 +1,72 @@
+%% Copyright 2014 Kolab Systems AG (http://www.kolabsys.com)
+%%
+%% Aaron Seigo (Kolab Systems) <seigo a kolabsys.com>
+%%
+%% This program is free software: you can redistribute it and/or modify
+%% it under the terms of the GNU Library 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 Library General Public License for more details.
+%%
+%% You should have received a copy of the GNU Library General Public License
+%% along with this program. If not, see <http://www.gnu.org/licenses/>.
+
+-module(eimap_command_switch_folder_tests).
+-include_lib("eunit/include/eunit.hrl").
+
+parse_test_() ->
+ Data =
+ [
+ % { Binary Response, Binary Tag, Parsed Results }
+ {
+ <<"Trash">>,
+ <<"* 0 EXISTS\r\n* 0 RECENT\r\n* FLAGS (\\\\Answered \\\\Flagged \\\\Draft \\\\Deleted \\\\Seen)\r\n* OK [PERMANENTFLAGS ()] Ok\r\n* OK [UIDVALIDITY 1447439786] Ok\r\n* OK [UIDNEXT 1] Ok\r\n* OK [HIGHESTMODSEQ 1] Ok\r\n* OK [URLMECH INTERNAL] Ok>\r\n* OK [ANNOTATIONS 65536] Ok\r\nabcd OK [READ-WRITE] SELECT completed\r\n">>,
+ <<"abcd">>,
+ { fini,
+ [
+ { writeable, true },
+ { annotations, 65536 },
+ { url_mech, internal },
+ { highest_mod_seq, 1 },
+ { uid_next, 1 },
+ { uid_validity, 1447439786 },
+ { permanent_flags, [] },
+ { flags, [<<"\\\\Answered">>, <<"\\\\Flagged">>, <<"\\\\Draft">>, <<"\\\\Deleted">>, <<"\\\\Seen">>] },
+ { recent, 0 },
+ { exists, 0 }
+ ]
+ }
+ },
+ {
+ <<"Nope">>,
+ <<"abcd BAD Uh uh uh\r\n">>,
+ <<"abcd">>,
+ { error, <<"Uh uh uh">> }
+ },
+ {
+ <<"ALsoWrong">>,
+ <<"abcd NO Uh uh uh\r\n">>,
+ <<"abcd">>,
+ { error, <<"Uh uh uh">> }
+ }
+ ],
+ lists:foldl(fun({ InitArgs, ServerResponse, Tag, Parsed }, Acc) ->
+ { _Command, ResponseType } = eimap_command_switch_folder:new_command(InitArgs),
+ [?_assertEqual(Parsed, eimap_command:parse_response(ResponseType, ServerResponse, Tag, eimap_command_switch_folder))|Acc] end, [], Data).
+
+new_test_() ->
+ Data =
+ [
+ % input, output
+ { "Trash", { <<"SELECT \"Trash\"">>, all_multiline_response } },
+ { <<"Trash">>, { <<"SELECT \"Trash\"">>, all_multiline_response } },
+ { { <<"Trash">>, select }, { <<"SELECT \"Trash\"">>, all_multiline_response } },
+ { { <<"Trash">>, examine }, { <<"EXAMINE \"Trash\"">>, all_multiline_response } },
+ { { "Trash", examine }, { <<"EXAMINE \"Trash\"">>, all_multiline_response } }
+ ],
+ lists:foldl(fun({ Params, Command }, Acc) -> [?_assertEqual(Command, eimap_command_switch_folder:new_command(Params))|Acc] end, [], Data).
+

guam-0.9.11.tar.gz/_checkouts/eimap/test/eimap_command_tests.erl Added

@@ -0,0 +1,65 @@
+%% Copyright 2014 Kolab Systems AG (http://www.kolabsys.com)
+%%
+%% Aaron Seigo (Kolab Systems) <seigo a kolabsys.com>
+%%
+%% This program is free software: you can redistribute it and/or modify
+%% it under the terms of the GNU Library 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 Library General Public License for more details.
+%%
+%% You should have received a copy of the GNU Library General Public License
+%% along with this program. If not, see <http://www.gnu.org/licenses/>.
+
+-module(eimap_command_tests).
+-include_lib("eunit/include/eunit.hrl").
+-export([process_line/2, formulate_response/2]).
+
+% c("test/eimap_command_tests.erl"). eunit:test(eimap_command).
+
+process_line(Data, Acc) -> [{ marked, Data } | Acc].
+formulate_response(Result, Data) -> eimap_command:formulate_response(Result, lists:reverse(Data)).
+
+
+literal_continuations_test_() ->
+ Data =
+ [
+ % input, output
+ % { Binary Response, Binary Tag, Parsed Results }
+ {
+ <<"* STATUS 1 (MESSAGES 231 {14}\r\nUIDNEXT 44292)\r\nabcd OK Begin TLS negotiation now\r\n">>,
+ <<"abcd">>,
+ { fini, [ { marked, <<"* STATUS 1 (MESSAGES 231 UIDNEXT 44292)">> } ] }
+ },
+ {
+ <<"* STATUS 1a (MESSAGES 231 {14}\r\nUIDNEXT 44292)\r\nabcd OK Begin TLS negotiation">>,
+ <<"abcd">>,
+ { more, { <<"abcd OK Begin TLS negotiation">>, [ { marked, <<"* STATUS 1a (MESSAGES 231 UIDNEXT 44292)">> } ], ?MODULE } }
+ },
+ {
+ <<"* STATUS 2 (MESSAGES 231 {14}\r\n">>,
+ <<"abcd">>,
+ { more, { <<"* STATUS 2 (MESSAGES 231 {14}">>, [], ?MODULE } }
+ },
+ {
+ <<"* STATUS 3 (MESSAGES 231 {h14}\r\nUIDNEXT 44292)\r\nabcd OK Begin TLS negotiation now\r\n">>,
+ <<"abcd">>,
+ { fini, [ { marked, <<"* STATUS 3 (MESSAGES 231 {h14}">> }, { marked, <<"UIDNEXT 44292)">> } ] }
+ },
+ {
+ <<"* STATUS 4 (MESSAGES 231 \r\nUIDNEXT 44292)\r\nabcd OK Begin TLS negotiation now\r\n">>,
+ <<"abcd">>,
+ { fini, [ { marked, <<"* STATUS 4 (MESSAGES 231 ">> }, { marked, <<"UIDNEXT 44292)">> } ] }
+ },
+ {
+ <<"* STATUS 5 (MESSAGES 231 UIDNEXT 44292)\r\nabcd OK Begin TLS negotiation now\r\n">>,
+ <<"abcd">>,
+ { fini, [ { marked, <<"* STATUS 5 (MESSAGES 231 UIDNEXT 44292)">> } ] }
+ }
+ ],
+ lists:foldl(fun({ Binary, Tag, Result }, Acc) -> [?_assertEqual(Result, eimap_command:parse_response(multiline_response, Binary, Tag, ?MODULE))|Acc] end, [], Data).
+

guam-0.9.11.tar.gz/_checkouts/eimap/test/eimap_uidset_tests.erl Added

@@ -0,0 +1,103 @@
+%% Copyright 2014 Kolab Systems AG (http://www.kolabsys.com)
+%%
+%% Aaron Seigo (Kolab Systems) <seigo a kolabsys.com>
+%%
+%% This program is free software: you can redistribute it and/or modify
+%% it under the terms of the GNU Library 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 Library General Public License for more details.
+%%
+%% You should have received a copy of the GNU Library General Public License
+%% along with this program. If not, see <http://www.gnu.org/licenses/>.
+
+-module(eimap_uidset_tests).
+-include_lib("eunit/include/eunit.hrl").
+
+% c("test/eimap_uidset_tests.erl"). eunit:test(eimap_uidset).
+
+new_test_() ->
+ Data =
+ [
+ % input, output
+ { [4], <<"4">> },
+ { [1, 2, 3, 4], <<"1,2,3,4">> },
+ { [-1, 1, 2, 3, 4], <<"1,2,3,4">> },
+ { [1, {100, 10}, 2, 3, 4], <<"1,10:100,2,3,4">> },
+ { [1, {10, 100}, 2, 3, 4], <<"1,10:100,2,3,4">> },
+ { [1, {-10, 100}, 2, 3, 4], <<"1,2,3,4">> },
+ { [1, {-100, 10}, 2, 3, 4], <<"1,2,3,4">> },
+ { [1, {-10, 100}, 2, 3, 4], <<"1,2,3,4">> },
+ { [1, {"alpha", 100}, <<"random_binary">>, some_atom, 2, 3, 4], <<"1,2,3,4">> },
+ { <<"1,2,3,4">>, <<>> },
+ { other, <<>> },
+ { [], <<>> }
+ ],
+ lists:foldl(fun({ List, Binary }, Acc) -> [?_assertEqual(Binary, eimap_uidset:uid_list_to_binary(List))|Acc] end, [], Data).
+
+single_value_test_() ->
+ [
+ ?_assertEqual([1], iterate_uidset(eimap_uidset:parse(<<"1,">>))),
+ ?_assertEqual([1], iterate_uidset(eimap_uidset:parse(<<"1">>))),
+ ?_assertEqual([20], iterate_uidset(eimap_uidset:parse(<<"20">>))),
+ ?_assertEqual([147], iterate_uidset(eimap_uidset:parse(<<"147">>)))
+ ].
+
+multiple_single_value_test_() ->
+ [
+ ?_assertEqual([1, 2], iterate_uidset(eimap_uidset:parse(<<"1,2">>)))
+ ].
+
+range_test_() ->
+ [
+ ?_assertEqual([1, 2, 3], iterate_uidset(eimap_uidset:parse(<<"1:3">>))),
+ ?_assertEqual([3, 2, 1], iterate_uidset(eimap_uidset:parse(<<"3:1">>))),
+ ?_assertEqual([1], iterate_uidset(eimap_uidset:parse(<<"1:1">>)))
+ ].
+
+multiple_range_test_() ->
+ [ ?_assertEqual([1, 2, 3, 10, 11, 12, 13, 14, 15], iterate_uidset(eimap_uidset:parse(<<"1:3,10:15">>))) ].
+
+mix_single_and_range_test_() ->
+ [
+ ?_assertEqual([1, 3, 4, 5], iterate_uidset(eimap_uidset:parse(<<"1,3:5">>))),
+ ?_assertEqual([1, 3, 4, 5, 10], iterate_uidset(eimap_uidset:parse(<<"1,3:5,10">>))),
+ ?_assertEqual([1, 3, 4, 5, 10, 20, 21, 22, 23, 30], iterate_uidset(eimap_uidset:parse(<<"1,3:5,10,20:23,30">>)))
+ ].
+
+mix_single_and_range_with_whitespace_test_() ->
+ [
+ ?_assertEqual(badarg, eimap_uidset:parse(<<"1, 3:5">>)),
+ ?_assertEqual(badarg, eimap_uidset:parse(<<"1,3:5 ,10">>)),
+ ?_assertEqual(badarg, eimap_uidset:parse(<<"1,3 :5,10,20: 23,30">>))
+ ].
+
+bad_uidsets_test_() ->
+ [
+ ?_assertEqual(badarg, iterate_uidset(eimap_uidset:parse(<<"">>))),
+ ?_assertEqual(badarg, iterate_uidset(eimap_uidset:parse(<<>>))),
+ ?_assertEqual(badarg, iterate_uidset(eimap_uidset:parse(<<"-1,3:5">>))),
+ ?_assertEqual(badarg, iterate_uidset(eimap_uidset:parse(<<"alpha">>))),
+ ?_assertEqual(badarg, iterate_uidset(eimap_uidset:parse(<<"1,a,3:5">>))),
+ ?_assertEqual(badarg, iterate_uidset(eimap_uidset:parse(<<"1,3:5,a">>))),
+ ?_assertEqual(badarg, iterate_uidset(eimap_uidset:parse(<<"1;2">>))),
+ ?_assertEqual(badarg, iterate_uidset(eimap_uidset:parse(<<"1, 2">>))),
+ ?_assertEqual(badarg, iterate_uidset(eimap_uidset:parse(<<"1:3:5">>))),
+ ?_assertEqual(badarg, iterate_uidset(eimap_uidset:parse(<<"-11,3:5">>))),
+ ?_assertEqual(badarg, iterate_uidset(eimap_uidset:parse(<<"11,-3:5">>))),
+ ?_assertEqual(badarg, iterate_uidset(eimap_uidset:parse(<<"11,3:-5">>)))
+ ].
+
+
+iterate_uidset(badarg) ->
+ badarg;
+iterate_uidset(UidSet) ->
+ %%io:fwrite("we are going to iterate over ~p~n", [UidSet]),
+ lists:reverse(iterate_uidset(eimap_uidset:next_uid(UidSet), [])).
+iterate_uidset({ none, _UidSet }, Acc) -> Acc;
+iterate_uidset({ Uid, UidSet }, Acc) -> iterate_uidset(eimap_uidset:next_uid(UidSet), [Uid|Acc]).
+

guam-0.9.11.tar.gz/_checkouts/eimap/test/eimap_utils_tests.erl Added

@@ -0,0 +1,200 @@
+%% Copyright 2014 Kolab Systems AG (http://www.kolabsys.com)
+%%
+%% Aaron Seigo (Kolab Systems) <seigo a kolabsys.com>
+%%
+%% This program is free software: you can redistribute it and/or modify
+%% it under the terms of the GNU Library 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 Library General Public License for more details.
+%%
+%% You should have received a copy of the GNU Library General Public License
+%% along with this program. If not, see <http://www.gnu.org/licenses/>.
+
+-module(eimap_utils_tests).
+-include_lib("eunit/include/eunit.hrl").
+
+% c("test/eimap_utils_tests.erl"). eunit:test(eimap_utils).
+
+extract_path_from_uri_test_() ->
+ Data =
+ [
+ {
+ <<"user/john.doe/Calendar@example.org">>,
+ none, "/",
+ <<"imap://john.doe@example.org@kolab.example.org/Calendar;UIDVALIDITY=1424683684/;UID=1">>
+ },
+ {
+ <<"user/john.doe/Personal Calendar@example.org">>,
+ none, "/",
+ <<"imap://john.doe@example.org@kolab.example.org/Personal%20Calendar;UIDVALIDITY=1424683684/;UID=1">>
+ },
+ {
+ <<"Personal Calendar">>,
+ none, "/",
+ <<"imap://kolab.example.org/Personal%20Calendar;UIDVALIDITY=1424683684/;UID=1">>
+ },
+ {
+ <<"Personal Calendar">>,
+ "Shared/", "/",
+ <<"imap://kolab.example.org/Shared/Personal%20Calendar;UIDVALIDITY=1424683684/;UID=1">>
+ },
+ {
+ <<"Personal Calendar">>,
+ "Shared/", "/",
+ <<"imap://kolab.example.org/Personal%20Calendar;UIDVALIDITY=1424683684/;UID=1">>
+ },
+ {
+ <<"user/john.doe@example.org">>,
+ "Shared/", "/",
+ <<"imap://john.doe@example.org@kolab.example.org/INBOX;UIDVALIDITY=1424683684/;UID=1">>
+ },
+ {
+ bad_uri,
+ none, "/",
+ <<"merf">>
+ }
+ ],
+ lists:foldl(fun({ Val, SharePrefix, Sep, Input }, Acc) -> [?_assertEqual(Val, eimap_utils:extract_path_from_uri(SharePrefix, Sep, Input))|Acc] end,
+ [], Data).
+
+extract_uid_from_uri_test_() ->
+ Data =
+ [
+ { <<"1">>, <<"imap://john.doe@example.org@kolab.example.org/Calendar;UIDVALIDITY=1424683684/;UID=1">> },
+ { <<"12">>, <<"imap://john.doe@example.org@kolab.example.org/Calendar;UIDVALIDITY=1424683684/;UID=12">> },
+ { <<"123">>, <<"imap://john.doe@example.org@kolab.example.org/Calendar;UIDVALIDITY=1424683684/;UID=123">> },
+ { <<"1">>, <<"imap://john.doe@example.org@kolab.example.org/Calendar;UIDVALIDITY=1424683684/;UID=1;foo">> },
+ { <<"12">>, <<"imap://john.doe@example.org@kolab.example.org/Calendar;UIDVALIDITY=1424683684/;UID=12;foo=bar">> },
+ { <<"123">>, <<"imap://john.doe@example.org@kolab.example.org/Calendar;UIDVALIDITY=1424683684/;UID=123;foo=bar">> }
+ ],
+ lists:foldl(fun({ Val, Input }, Acc) -> [?_assertEqual(Val, eimap_utils:extract_uidset_from_uri(Input))|Acc] end,
+ [], Data).
+
+split_command_into_components_test_() ->
+ Data =
+ [
+ { { <<>>, <<>>, <<>> }, <<>> },
+ { { <<>>, <<"DONE">>, <<>> }, <<"DONE\r\n">> },
+ { { <<".">>, <<"LIST">>, <<"\"\" \"*\"">> }, <<". LIST \"\" \"*\"">> },
+ { { <<"1">>, <<"STARTTLS">>, <<>> }, <<"1 STARTTLS">> },
+ { { <<"1">>, <<"STARTTLS">>, <<>> }, <<"1 STARTTLS\r\n">> },
+ { { <<"3">>, <<"ID">>, <<"(\"name\" \"Thunderbird\" \"version\" \"38.3.0\")">> }, <<"3 ID (\"name\" \"Thunderbird\" \"version\" \"38.3.0\")">> }
+ ],
+ lists:foldl(fun({ Val, Input }, Acc) -> [?_assertEqual(Val, eimap_utils:split_command_into_components(Input)) | Acc] end,
+ [], Data).
+
+check_response_for_failure_test_() ->
+ Tag = <<"abcdef">>,
+ Data =
+ [
+ { Tag, <<Tag/binary, " NO reasons\r\n">>, { no, <<"reasons">> } },
+ { Tag, <<Tag/binary, " NO reasons">>, { no, <<"reasons">> } },
+ { Tag, <<Tag/binary, " BAD reasons\r\n">>, { bad, <<"reasons">> } },
+ { Tag, <<Tag/binary, " BAD reasons">>, { bad, <<"reasons">> } },
+ { Tag, <<Tag/binary, " OK reasons">>, ok },
+ { Tag, <<"short">>, ok },
+ { undefined, <<"* OK reasons">>, ok }
+ ],
+ lists:foldl(fun({ Tag2, Input, Output}, Acc) -> [?_assertEqual(Output, eimap_utils:check_response_for_failure(Input, Tag2)) | Acc] end, [], Data).
+
+is_tagged_response_test_() ->
+ Tag = <<"abcd">>,
+ Data =
+ [
+ { <<Tag/binary, " Indeed\r\n">>, tagged },
+ { <<Tag/binary, " Indeed">>, tagged },
+ { <<"one">>, untagged },
+ { <<"* Yeah baby">>, untagged }
+ ],
+ lists:foldl(fun({ Input, Output}, Acc) -> [?_assertEqual(Output, eimap_utils:is_tagged_response(Input, Tag)) | Acc] end, [], Data).
+
+remove_tag_from_response_test_() ->
+ Tag = <<"abcd">>,
+ Data =
+ [
+ { Tag, <<Tag/binary, " Indeed\r\n">>, check, <<"Indeed\r\n">> },
+ { Tag, <<Tag/binary, " Indeed\r\n">>, trust, <<"Indeed\r\n">> },
+ { Tag, <<Tag/binary, " Indeed">>, check, <<"Indeed">>},
+ { Tag, <<Tag/binary, " Indeed">>, trust, <<"Indeed">>},
+ { undefined, <<"abcd4 Indeed">>, check, <<"abcd4 Indeed">>},
+ { undefined, <<"abcd4 Indeed">>, trust, <<"abcd4 Indeed">>},
+ { <<>>, <<"abcd4 Indeed">>, check, <<"abcd4 Indeed">>},
+ { <<>>, <<"abcd4 Indeed">>, trust, <<"abcd4 Indeed">>},
+ { Tag, <<"abcd4 Indeed">>, check, <<"abcd4 Indeed">>},
+ { Tag, <<"abcd4 Indeed">>, trust, <<" Indeed">>},
+ { Tag, <<"* Yeah baby">>, check, <<"* Yeah baby">> },
+ { Tag, <<"">>, check, <<"">> },
+ { Tag, <<"">>, trust, <<"">> },
+ { Tag, <<>>, check, <<>> },
+ { Tag, <<>>, trust, <<>> }
+ ],
+ lists:foldl(fun({ Tag2, Input, Check, Output}, Acc) -> [?_assertEqual(Output, eimap_utils:remove_tag_from_response(Input, Tag2, Check)) | Acc] end, [], Data).
+
+header_name_test_() ->
+ Data =
+ [
+ { mailbox_uid , <<"/vendor/cmu/cyrus-imapd/uniqueid">> },
+ { groupware_type , <<"X-Kolab-Type">> },
+ { groupware_uid , <<"Subject">> },
+ { dunno, unknown },
+ { "dunno", unknown },
+ { <<"dunno">>, unknown },
+ { 134, unknown }
+ ],
+ lists:foldl(fun({ Input, Output}, Acc) -> [?_assertEqual(Output, eimap_utils:header_name(Input)) | Acc] end, [], Data).
+
+ensure_binary_test_() ->
+ Data = 
+ [
+ { "yep", <<"yep">> },
+ { <<"yep">>, <<"yep">> },
+ { [1, 2, 3], <<1, 2, 3>> },
+ { yep, <<"yep">> },
+ { 123, <<>> }
+ ],
+ lists:foldl(fun({ Input, Output}, Acc) -> [?_assertEqual(Output, eimap_utils:ensure_binary(Input)) | Acc] end, [], Data).
+
+only_full_lines_test_() ->
+ Data = 
+ [
+ { <<"yep">>, { <<>>, <<"yep">> } },
+ { <<"yep\r\nhohoho">>, { <<"yep\r\n">>, <<"hohoho">> } },
+ { <<"nope\r\nyep\r\nhohoho">>, { <<"nope\r\nyep\r\n">>, <<"hohoho">> } },
+ { <<"nope\r\nyep\r\nhohoho\r\n">>, { <<"nope\r\nyep\r\nhohoho\r\n">>, <<>> } }
+ ],
+ lists:foldl(fun({ Input, Output}, Acc) -> [?_assertEqual(Output, eimap_utils:only_full_lines(Input)) | Acc] end, [], Data).
+
+parse_flags_test_() ->
+ Data =
+ [
+ { <<"()">>, [] },
+ { <<>>, [] },
+ { <<"\\\\Answered \\\\Flagged \\\\Draft \\\\Deleted \\\\Seen">>, [<<"\\\\Answered">>, <<"\\\\Flagged">>, <<"\\\\Draft">>, <<"\\\\Deleted">>, <<"\\\\Seen">> ] },
+ { <<"(\\\\Answered \\\\Flagged \\\\Draft \\\\Deleted \\\\Seen)">>, [<<"\\\\Answered">>, <<"\\\\Flagged">>, <<"\\\\Draft">>, <<"\\\\Deleted">>, <<"\\\\Seen">> ] },
+ { "(\\\\Answered \\\\Flagged \\\\Draft \\\\Deleted \\\\Seen)", [<<"\\\\Answered">>, <<"\\\\Flagged">>, <<"\\\\Draft">>, <<"\\\\Deleted">>, <<"\\\\Seen">> ] }
+ ],
+ lists:foldl(fun({ Input, Output}, Acc) -> [?_assertEqual(Output, eimap_utils:parse_flags(Input)) | Acc] end, [], Data).
+
+num_literal_continuation_bytes_test_() ->
+ Data =
+ [
+ { <<"abcd">>, { <<"abcd">>, 0 } },
+ { <<"abcd{5}">>, { <<"abcd">>, 5 } },
+ { <<"abcd{100}">>, { <<"abcd">>, 100 } },
+ { <<"123abcd{100}">>, { <<"123abcd">>, 100 } },
+ { <<"ab{123abcd{100}">>, { <<"ab{123abcd">>, 100 } },
+ { <<"ab{123abcd{1{00}">>, { <<"ab{123abcd{1">>, 0 } },
+ { <<"abcd{aa0}">>, { <<"abcd{aa0}">>, 0 } },
+ { <<"abcd{10aa0}">>, { <<"abcd{10aa0}">>, 0 } },
+ { <<"abcd100}">>, { <<"abcd100}">>, 0 } },
+ { <<"abcd100}">>, { <<"abcd100}">>, 0 } },
+ { <<"abcd{5+}">>, { <<"abcd">>, 5 } }
+ ],
+ lists:foldl(fun({ Input, Output}, Acc) -> [?_assertEqual(Output, eimap_utils:num_literal_continuation_bytes(Input)) | Acc] end, [], Data).
+
+

guam-0.9.11.tar.gz/_checkouts/goldrush Added

guam-0.9.11.tar.gz/_checkouts/goldrush/LICENSE Added

guam-0.9.11.tar.gz/_checkouts/goldrush/README.org Added

@@ -0,0 +1,336 @@
+# Goldrush #
+
+Goldrush is a small Erlang app that provides fast event stream processing
+
+# Features #
+* Event processing compiled to a query module
+ - per module private event processing statistics
+ - query module logic can be combined for any/all filters
+ - query module logic can be reduced to efficiently match event processing
+
+* Complex event processing logic
+ - match input events with greater than (gt) logic
+ - match input events with less than (lt) logic
+ - match input events with equal to (eq) logic
+ - match input events with wildcard (wc) logic
+ - match input events with notfound (nf) logic
+ - match no input events (null blackhole) logic
+ - match all input events (null passthrough) logic
+
+* Handle output events
+ - Once a query has been composed the output action can be overriden
+   with one or more erlang functions. The functions will be applied to each
+   output event from the query.
+
+* Handle low latency retrieval of compile-time stored values.
+- Values stored are also provided to functions called on event output.
+- Handle job execution and timing which can also get values stored
+- create input events that include runtime on successful function executions.
+
+* Handle fastest lookups of stored values.
+- provide state storage option to compile, caching the values in query module.
+
+* Usage 
+  To use goldrush in your application, you need to define it as a rebar dep or
+  include it in erlang's path.
+
+
+Before composing modules, you'll need to define a query. The query syntax 
+matches any number of `{erlang, terms}' and is composed as follows:
+
+* Simple Logic 
+ - Simple logic is defined as any logic matching a single event filter
+
+Select all events where 'a' exists and is greater than 0.
+#+BEGIN_EXAMPLE
+    glc:gt(a, 0).
+#+END_EXAMPLE
+
+Select all events where 'a' exists and is greater than or equal to 0.
+#+BEGIN_EXAMPLE
+    glc:gte(a, 0).
+#+END_EXAMPLE
+
+Select all events where 'a' exists and is equal to 0.
+#+BEGIN_EXAMPLE
+    glc:eq(a, 0).
+#+END_EXAMPLE
+
+Select all events where 'a' exists and is not equal to 0.
+#+BEGIN_EXAMPLE
+    glc:neq(a, 0).
+#+END_EXAMPLE
+
+Select all events where 'a' exists and is less than 0.
+#+BEGIN_EXAMPLE
+    glc:lt(a, 0).
+#+END_EXAMPLE
+
+Select all events where 'a' exists and is less than or equal to 0.
+#+BEGIN_EXAMPLE
+    glc:lte(a, 0).
+#+END_EXAMPLE
+
+Select all events where 'a' exists.
+#+BEGIN_EXAMPLE
+    glc:wc(a).
+#+END_EXAMPLE
+
+Select all events where 'a' does not exist.
+#+BEGIN_EXAMPLE
+    glc:nf(a).
+#+END_EXAMPLE
+
+Select no input events. User as a black hole query.
+#+BEGIN_EXAMPLE
+    glc:null(false).
+#+END_EXAMPLE
+
+Select all input events. Used as a passthrough query.
+#+BEGIN_EXAMPLE
+    glc:null(true).
+#+END_EXAMPLE
+
+
+* Combined Logic
+ - Combined logic is defined as logic matching multiple event filters
+
+Select all events where both 'a' AND 'b' exists and are greater than 0.
+#+BEGIN_EXAMPLE
+    glc:all([glc:gt(a, 0), glc:gt(b, 0)]).
+#+END_EXAMPLE
+
+Select all events where 'a' OR 'b' exists and are greater than 0.
+#+BEGIN_EXAMPLE
+    glc:any([glc:gt(a, 0), glc:gt(b, 0)]).
+#+END_EXAMPLE
+
+Select all events where 'a' AND 'b' exists where 'a' is greater than 1 and 'b' is less than 2.
+#+BEGIN_EXAMPLE
+    glc:all([glc:gt(a, 1), glc:lt(b, 2)]).
+#+END_EXAMPLE
+
+Select all events where 'a' OR 'b' exists where 'a' is greater than 1 and 'b' is less than 2.
+#+BEGIN_EXAMPLE
+    glc:any([glc:gt(a, 1), glc:lt(b, 2)]).
+#+END_EXAMPLE
+
+
+* Reduced Logic
+ - Reduced logic is defined as logic which can be simplified to improve efficiency.
+
+Select all events where 'a' is equal to 1, 'b' is equal to 2 and 'c' is equal to 3 and collapse any duplicate logic.
+#+BEGIN_EXAMPLE
+        glc_lib:reduce(
+            glc:all([
+                glc:any([glc:eq(a, 1), glc:eq(b, 2)]),
+                glc:any([glc:eq(a, 1), glc:eq(c, 3)])])).
+#+END_EXAMPLE
+
+The previous example will produce and is equivalent to:
+#+BEGIN_EXAMPLE
+    glc:all([glc:eq(a, 1), glc:eq(b, 2), glc:eq(c, 3)]).
+#+END_EXAMPLE
+
+
+
+* Composing Modules 
+  - All query modules must be compiled before use
+
+To compose a module you will take your Query defined above and compile it. 
+#+BEGIN_EXAMPLE
+    glc:compile(Module, Query).
+    glc:compile(Module, Query, State).
+    glc:compile(Module, Query, State, ResetStatistics).
+#+END_EXAMPLE
+
+
+- At this point you will be able to handle an event using a compiled query. 
+
+Begin by constructing an event list.
+#+BEGIN_EXAMPLE
+    Event = gre:make([{'a', 2}], [list]).
+#+END_EXAMPLE
+
+Now pass it to your query module to be handled.
+#+BEGIN_EXAMPLE
+    glc:handle(Module, Event).
+#+END_EXAMPLE
+
+* Handling output events
+  - You can override the output action with an erlang function.
+
+Write all input events as info reports to the error logger.
+#+BEGIN_EXAMPLE
+    glc:with(glc:null(true), fun(E) ->
+         error_logger:info_report(gre:pairs(E)) end).
+#+END_EXAMPLE
+
+Write all input events where `error_level' exists and is less than 5 as info reports to the error logger.
+#+BEGIN_EXAMPLE
+    glc:with(glc:lt(error_level, 5), fun(E) ->
+         error_logger:info_report(gre:pairs(E)) end).
+#+END_EXAMPLE
+
+Write all input events where `error_level' exists and is 3 or 5 as info reports to the error logger.
+#+BEGIN_EXAMPLE
+   glc:any([
+     glc:with(glc:lt(error_level, 3), fun(E) ->
+         error_logger:info_report(gre:pairs(E)) end),
+     glc:with(glc:lt(error_level, 5), fun(E) ->
+         error_logger:info_report(gre:pairs(E)) end)]).
+
+#+END_EXAMPLE
+
+
+# Composing Modules with stored state #
+
+To compose a module with state data you will add a third argument (orddict).
+#+BEGIN_EXAMPLE
+    glc:compile(Module, Query, [{stored, value}]).
+#+END_EXAMPLE
+
+# Accessing stored state data #
+
+Return the stored value in this query module.
+#+BEGIN_EXAMPLE
+{ok, value} = glc:get(stored).
+#+END_EXAMPLE
+
+Return all stored values in this query module.
+#+BEGIN_EXAMPLE
+[...] = Module:get().
+#+END_EXAMPLE
+
+
+* Composing Modules with stored data
+  - You can create query modules with local state to compare to event data in `with' and `run'
+
+To compose a module with state data you will add a third argument (orddict).
+#+BEGIN_EXAMPLE
+    glc:compile(Module, Query, [{stored, value}]).
+#+END_EXAMPLE
+
+* Accessing stored data in constant time 
+ - You can use query modules in a way similar to mochiglobal 
+
+Return the stored value in this query module.
+#+BEGIN_EXAMPLE
+{ok, value} = glc:get(stored).
+#+END_EXAMPLE
+
+
+* Job processing with composed modules 
+  - You can use query modules to execute jobs, if the job errors or not, process an event.
+  - `with' is similar to `run', the main difference is additional statistics and execution order
+  - when a job completes in error, the event data will contain an additional {error, _} item
+
+To execute a job through the query module, inputting an event on success.
+#+BEGIN_EXAMPLE
+    Event = gre:make([{'a', 2}], [list]).
+    {ExecutionTime, Result}= glc:run(Module, fun(Event, State) ->
+        %% do not end with {error, _} or throw an exception 
+    end, Event).
+#+END_EXAMPLE
+
+* Event Processing Statistics 
+
+Return the number of input events for this query module.
+#+BEGIN_EXAMPLE
+glc:input(Module).
+#+END_EXAMPLE
+
+Return the number of output events for this query module.
+#+BEGIN_EXAMPLE
+glc:output(Module).
+#+END_EXAMPLE
+
+Return the number of filtered events for this query module.
+#+BEGIN_EXAMPLE
+glc:filter(Module).
+#+END_EXAMPLE
+
+
+* Job Processing Statistics 
+
+Return the number of job runs for this query module.
+#+BEGIN_EXAMPLE
+glc:job_run(Module).
+#+END_EXAMPLE
+
+Return the number of job errors for this query module.
+#+BEGIN_EXAMPLE
+glc:job_error(Module).
+#+END_EXAMPLE
+
+Return the number of job inputs for this query module.
+#+BEGIN_EXAMPLE
+glc:job_input(Module).
+#+END_EXAMPLE
+
+Return the amount of time jobs took for this query module.
+#+BEGIN_EXAMPLE
+glc:job_time(Module).
+#+END_EXAMPLE
+
+
+* Some Tips & Tricks 
+  - This is really just a drop in the bucket.
+
+Return the average time jobs took for this query module.
+#+BEGIN_EXAMPLE
+glc:job_time(Module) / glc:job_input(Module) / 1000000.
+#+END_EXAMPLE
+
+
+Return the query combining the conditional logic of multiple modules 
+#+BEGIN_EXAMPLE
+glc_lib:reduce(glc:all([Module1:info('query'), Module2:info('query')]).
+#+END_EXAMPLE
+
+Return all statistics from this query module.
+#+BEGIN_EXAMPLE
+glc:info(Module).
+#+END_EXAMPLE
+
+* Build
+
+#+BEGIN_EXAMPLE
+ $ ./rebar compile
+#+END_EXAMPLE
+
+or
+
+#+BEGIN_EXAMPLE
+    $ make
+#+END_EXAMPLE
+
+* CHANGELOG 
+0.1.9
+- Add support for running jobs
+
+0.1.8
+- Add support for not equal
+
+0.1.7
+- Support multiple functions specified using `with/2` 
+- Add support for greater than or less than operators
+- Add state storage option for output events or lookup
+
+0.1.7
+- Add job execution and timings
+- Add state storage option 
+
+0.1.7
+- Add job execution and timings
+- Add state storage option 
+
+0.1.6 
+- Add notfound event matching
+
+0.1.5 
+- Rewrite to make highly crash resilient
+  - per module supervision
+  - statistics data recovery 
+- Add wildcard event matching
+- Add reset counters

guam-0.9.11.tar.gz/_checkouts/goldrush/hex_metadata.config Added

guam-0.9.11.tar.gz/_checkouts/goldrush/priv Added

guam-0.9.11.tar.gz/_checkouts/goldrush/priv/edoc.css Added

@@ -0,0 +1,130 @@
+/* Baseline rhythm */
+body {
+   font-size: 16px;
+   font-family: Helvetica, sans-serif;
+   margin: 8px;
+}
+
+p {
+   font-size: 1em; /* 16px */
+   line-height: 1.5em; /* 24px */
+   margin: 0 0 1.5em 0;
+}
+
+h1 {
+   font-size: 1.5em; /* 24px */
+   line-height: 1em; /* 24px */
+   margin-top: 1em;
+   margin-bottom: 0em;
+}
+
+h2 {
+   font-size: 1.375em; /* 22px */
+   line-height: 1.0909em; /* 24px */
+   margin-top: 1.0909em;
+   margin-bottom: 0em;
+}
+
+h3 {
+   font-size: 1.25em; /* 20px */
+   line-height: 1.2em; /* 24px */
+   margin-top: 1.2em;
+   margin-bottom: 0em;
+}
+
+h4 {
+   font-size: 1.125em; /* 18px */
+   line-height: 1.3333em; /* 24px */
+   margin-top: 1.3333em;
+   margin-bottom: 0em;
+}
+
+.class-for-16px {
+   font-size: 1em; /* 16px */
+   line-height: 1.5em; /* 24px */
+   margin-top: 1.5em;
+   margin-bottom: 0em;
+}
+
+.class-for-14px {
+   font-size: 0.875em; /* 14px */
+   line-height: 1.7143em; /* 24px */
+   margin-top: 1.7143em;
+   margin-bottom: 0em;
+}
+
+ul {
+   margin: 0 0 1.5em 0;
+}
+
+/* Customizations */
+body {
+   color: #333;
+}
+
+tt, code, pre {
+   font-family: "Andale Mono", "Inconsolata", "Monaco", "DejaVu Sans Mono", monospaced;
+}
+
+tt, code { font-size: 0.875em }
+
+pre {
+   font-size: 0.875em; /* 14px */
+   line-height: 1.7143em; /* 24px */
+   margin: 0 1em 1.7143em;
+   padding: 0 1em;
+   background: #eee;
+}
+
+.navbar img, hr { display: none }
+
+table {
+   border-collapse: collapse;
+}
+
+h1 {
+   border-left: 0.5em solid #fa0;
+   padding-left: 0.5em;
+}
+
+h2.indextitle {
+   font-size: 1.25em; /* 20px */
+   line-height: 1.2em; /* 24px */
+   margin: -8px -8px 0.6em;
+   background-color: #fa0;
+   color: white;
+   padding: 0.3em;
+}
+
+ul.index {
+   list-style: none;
+   margin-left: 0em;
+   padding-left: 0;
+}
+
+ul.index li {
+   display: inline;
+   padding-right: 0.75em
+}
+
+div.spec p {
+   margin-bottom: 0;
+   padding-left: 1.25em;
+   background-color: #eee;
+}
+
+h3.function {
+   border-left: 0.5em solid #fa0;
+   padding-left: 0.5em;
+   background: #fc9;
+}
+a, a:visited, a:hover, a:active { color: #C60 }
+h2 a, h3 a { color: #333 }
+
+i {
+   font-size: 0.875em; /* 14px */
+   line-height: 1.7143em; /* 24px */
+   margin-top: 1.7143em;
+   margin-bottom: 0em;
+   font-style: normal;
+}

guam-0.9.11.tar.gz/_checkouts/goldrush/rebar.config Added

guam-0.9.11.tar.gz/_checkouts/goldrush/rebar.lock Added

guam-0.9.11.tar.gz/_checkouts/goldrush/src Added

guam-0.9.11.tar.gz/_checkouts/goldrush/src/glc.erl Added

@@ -0,0 +1,1034 @@
+%% Copyright (c) 2012, Magnus Klaar <klaar@ninenines.eu>
+%%
+%% Permission to use, copy, modify, and/or distribute this software for any
+%% purpose with or without fee is hereby granted, provided that the above
+%% copyright notice and this permission notice appear in all copies.
+%%
+%% THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+%% WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+%% MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+%% ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+%% WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+%% ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+%% OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+
+%% @doc Event filter implementation.
+%%
+%% An event query is constructed using the built in operators exported from
+%% this module. The filtering operators are used to specify which events
+%% should be included in the output of the query. The default output action
+%% is to copy all events matching the input filters associated with a query
+%% to the output. This makes it possible to construct and compose multiple
+%% queries at runtime.
+%%
+%% === Examples of built in filters ===
+%% ```
+%% %% Select all events where 'a' exists and is greater than 0.
+%% glc:gt(a, 0).
+%% %% Select all events where 'a' exists and is equal to 0.
+%% glc:eq(a, 0).
+%% %% Select all events where 'a' exists and is not equal to 0.
+%% glc:neq(a, 0).
+%% %% Select all events where 'a' exists and is less than 0.
+%% glc:lt(a, 0).
+%% %% Select all events where 'a' exists and is anything.
+%% glc:wc(a).
+%%
+%% %% Select no input events. Used as black hole query.
+%% glc:null(false).
+%% %% Select all input events. Used as passthrough query.
+%% glc:null(true).
+%% '''
+%%
+%% === Examples of combining filters ===
+%% ```
+%% %% Select all events where both 'a' and 'b' exists and are greater than 0.
+%% glc:all([glc:gt(a, 0), glc:gt(b, 0)]).
+%% %% Select all events where 'a' or 'b' exists and are greater than 0.
+%% glc:any([glc:gt(a, 0), glc:gt(b, 0)]).
+%% '''
+%%
+%% === Handling output events ===
+%%
+%% Once a query has been composed it is possible to override the output action
+%% with an erlang function. The function will be applied to each output event
+%% from the query. The return value from the function will be ignored.
+%%
+%% ```
+%% %% Write all input events as info reports to the error logger.
+%% glc:with(glc:null(true), fun(E) ->
+%% error_logger:info_report(gre:pairs(E)) end).
+%% '''
+%%
+-module(glc).
+
+-export([
+ compile/2,
+ compile/3,
+ compile/4,
+ handle/2,
+ get/2,
+ delete/1,
+ reset_counters/1,
+ reset_counters/2,
+ start/0
+]).
+
+-export([
+ lt/2, lte/2,
+ eq/2, neq/2,
+ gt/2, gte/2,
+ wc/1,
+ nf/1
+]).
+
+-export([
+ all/1,
+ any/1,
+ null/1,
+ with/2,
+ run/3
+]).
+
+-export([
+ info/1,
+ input/1,
+ output/1,
+ job_input/1,
+ job_run/1,
+ job_error/1,
+ job_time/1,
+ filter/1,
+ union/1
+]).
+
+-record(module, {
+ 'query' :: term(),
+ tables :: [{atom(), atom()}],
+ qtree :: term(),
+ store :: term()
+}).
+
+-spec lt(atom(), term()) -> glc_ops:op().
+lt(Key, Term) ->
+ glc_ops:lt(Key, Term).
+
+-spec lte(atom(), term()) -> glc_ops:op().
+lte(Key, Term) ->
+ glc_ops:lte(Key, Term).
+
+-spec eq(atom(), term()) -> glc_ops:op().
+eq(Key, Term) ->
+ glc_ops:eq(Key, Term).
+
+-spec neq(atom(), term()) -> glc_ops:op().
+neq(Key, Term) ->
+ glc_ops:neq(Key, Term).
+
+-spec gt(atom(), term()) -> glc_ops:op().
+gt(Key, Term) ->
+ glc_ops:gt(Key, Term).
+
+-spec gte(atom(), term()) -> glc_ops:op().
+gte(Key, Term) ->
+ glc_ops:gte(Key, Term).
+
+-spec wc(atom()) -> glc_ops:op().
+wc(Key) ->
+ glc_ops:wc(Key).
+
+-spec nf(atom()) -> glc_ops:op().
+nf(Key) ->
+ glc_ops:nf(Key).
+
+%% @doc Filter the input using multiple filters.
+%%
+%% For an input to be considered valid output the all filters specified
+%% in the list must hold for the input event. The list is expected to
+%% be a non-empty list. If the list of filters is an empty list a `badarg'
+%% error will be thrown.
+-spec all([glc_ops:op()]) -> glc_ops:op().
+all(Filters) ->
+ glc_ops:all(Filters).
+
+
+%% @doc Filter the input using one of multiple filters.
+%%
+%% For an input to be considered valid output on of the filters specified
+%% in the list must hold for the input event. The list is expected to be
+%% a non-empty list. If the list of filters is an empty list a `badarg'
+%% error will be thrown.
+-spec any([glc_ops:op()]) -> glc_ops:op().
+any(Filters) ->
+ glc_ops:any(Filters).
+
+
+%% @doc Always return `true' or `false'.
+-spec null(boolean()) -> glc_ops:op().
+null(Result) ->
+ glc_ops:null(Result).
+
+
+%% @doc Apply a function to each output of a query.
+%%
+%% Updating the output action of a query finalizes it. Attempting
+%% to use a finalized query to construct a new query will result
+%% in a `badarg' error.
+-spec with(glc_ops:op(), fun((gre:event()) -> term())) -> glc_ops:op().
+with(Query, Action) ->
+ glc_ops:with(Query, Action).
+
+
+%% @doc Return a union of multiple queries.
+%%
+%% The union of multiple queries is the equivalent of executing multiple
+%% queries separately on the same input event. The advantage is that filter
+%% conditions that are common to all or some of the queries only need to
+%% be tested once.
+%%
+%% All queries are expected to be valid and have an output action other
+%% than the default which is `output'. If these expectations don't hold
+%% a `badarg' error will be thrown.
+-spec union([glc_ops:op()]) -> glc_ops:op().
+union(Queries) ->
+ glc_ops:union(Queries).
+
+
+%% @doc Compile a query to a module.
+%%
+%% On success the module representing the query is returned. The module and
+%% data associated with the query must be released using the {@link delete/1}
+%% function. The name of the query module is expected to be unique.
+%% The counters are reset by default, unless Reset is set to false 
+-spec compile(atom(), glc_ops:op() | [glc_ops:op()]) -> {ok, atom()}.
+compile(Module, Query) ->
+ compile(Module, Query, undefined, true).
+
+-spec compile(atom(), glc_ops:op() | [glc_ops:op()], boolean()) -> {ok, atom()}.
+compile(Module, Query, Reset) when is_boolean(Reset) ->
+ compile(Module, Query, undefined, Reset);
+compile(Module, Query, undefined) ->
+ compile(Module, Query, undefined, true);
+compile(Module, Query, Store) when is_list(Store) ->
+ compile(Module, Query, Store, true).
+
+compile(Module, Query, Store, Reset) ->
+ {ok, ModuleData} = module_data(Module, Query, Store),
+ case glc_code:compile(Module, ModuleData) of
+ {ok, Module} when Reset ->
+ reset_counters(Module),
+ {ok, Module};
+ {ok, Module} ->
+ {ok, Module}
+ end.
+
+
+%% @doc Handle an event using a compiled query.
+%%
+%% The input event is expected to have been returned from {@link gre:make/2}.
+-spec handle(atom(), list({atom(), term()}) | gre:event()) -> ok.
+handle(Module, Event) when is_list(Event) ->
+ Module:handle(gre:make(Event, [list]));
+handle(Module, Event) ->
+ Module:handle(Event).
+
+get(Module, Key) ->
+ Module:get(Key).
+
+run(Module, Fun, Event) when is_list(Event) ->
+ Module:runjob(Fun, gre:make(Event, [list]));
+run(Module, Fun, Event) ->
+ Module:runjob(Fun, Event).
+
+
+info(Module) ->
+ Counters = [input, filter, output, 
+ job_input, job_run, 
+ job_time, job_error],
+ [ {C, Module:info(C)} || C <- ['query' | Counters] ].
+
+%% @doc The number of input events for this query module.
+-spec input(atom()) -> non_neg_integer().
+input(Module) ->
+ Module:info(input).
+
+%% @doc The number of output events for this query module.
+-spec output(atom()) -> non_neg_integer().
+output(Module) ->
+ Module:info(output).
+
+%% @doc The number of filtered events for this query module.
+-spec filter(atom()) -> non_neg_integer().
+filter(Module) ->
+ Module:info(filter).
+
+
+%% @doc The number of job runs for this query module.
+-spec job_run(atom()) -> non_neg_integer().
+job_run(Module) ->
+ Module:info(job_run).
+
+%% @doc The number of job errors for this query module.
+-spec job_error(atom()) -> non_neg_integer().
+job_error(Module) ->
+ Module:info(job_error).
+
+%% @doc The number of job inputs for this query module.
+-spec job_input(atom()) -> non_neg_integer().
+job_input(Module) ->
+ Module:info(job_input).
+
+%% @doc The amount of time jobs took for this query module.
+-spec job_time(atom()) -> non_neg_integer().
+job_time(Module) ->
+ Module:info(job_time).
+
+%% @doc Release a compiled query.
+%%
+%% This releases all resources allocated by a compiled query. The query name
+%% is expected to be associated with an existing query module. Calling this
+%% function will shutdown all relevant processes and purge/delete the module.
+-spec delete(atom()) -> ok.
+delete(Module) ->
+ Params = params_name(Module),
+ Counts = counts_name(Module),
+ ManageParams = manage_params_name(Module),
+ ManageCounts = manage_counts_name(Module),
+
+ _ = [ begin 
+ ok = supervisor:terminate_child(Sup, Name),
+ ok = supervisor:delete_child(Sup, Name)
+ end || {Sup, Name} <- 
+ [{gr_manager_sup, ManageParams}, {gr_manager_sup, ManageCounts},
+ {gr_param_sup, Params}, {gr_counter_sup, Counts}]
+ ],
+
+ code:soft_purge(Module),
+ code:delete(Module),
+ ok.
+
+%% @doc Reset all counters
+%%
+%% This resets all the counters associated with a module
+-spec reset_counters(atom()) -> ok.
+reset_counters(Module) ->
+ Module:reset_counters(all).
+
+%% @doc Reset a specific counter
+%%
+%% This resets a specific counter associated with a module
+-spec reset_counters(atom(), atom()) -> ok.
+reset_counters(Module, Counter) ->
+ Module:reset_counters(Counter).
+
+%% @private Map a query to a module data term.
+-spec module_data(atom(), term(), term()) -> {ok, #module{}}.
+module_data(Module, Query, Store) ->
+ %% terms in the query which are not valid arguments to the
+ %% erl_syntax:abstract/1 functions are stored in ETS.
+ %% the terms are only looked up once they are necessary to
+ %% continue evaluation of the query.
+
+ %% query counters are stored in a shared ETS table. this should
+ %% be an optional feature. enabled by defaults to simplify tests.
+ %% the abstract_tables/1 function expects a list of name-atom pairs.
+ %% tables are referred to by name in the generated code. the table/1
+ %% function maps names to registered processes response for those tables.
+ Tables = module_tables(Module),
+ Query2 = glc_lib:reduce(Query),
+ {ok, #module{'query'=Query, tables=Tables, qtree=Query2, store=Store}}.
+
+%% @private Create a data managed supervised process for params, counter tables
+module_tables(Module) ->
+ Params = params_name(Module),
+ Counts = counts_name(Module),
+ ManageParams = manage_params_name(Module),
+ ManageCounts = manage_counts_name(Module),
+ Counters = [{input,0}, {filter,0}, {output,0}, 
+ {job_input, 0}, {job_run,0}, {job_time, 0},
+ {job_error, 0}],
+
+ _ = supervisor:start_child(gr_param_sup, 
+ {Params, {gr_param, start_link, [Params]}, 
+ transient, brutal_kill, worker, [Params]}),
+ _ = supervisor:start_child(gr_counter_sup, 
+ {Counts, {gr_counter, start_link, [Counts]}, 
+ transient, brutal_kill, worker, [Counts]}),
+ _ = supervisor:start_child(gr_manager_sup, 
+ {ManageParams, {gr_manager, start_link, [ManageParams, Params, []]},
+ transient, brutal_kill, worker, [ManageParams]}),
+ _ = supervisor:start_child(gr_manager_sup, {ManageCounts, 
+ {gr_manager, start_link, [ManageCounts, Counts, Counters]},
+ transient, brutal_kill, worker, [ManageCounts]}),
+ [{params,Params}, {counters, Counts}].
+
+reg_name(Module, Name) ->
+ list_to_atom("gr_" ++ atom_to_list(Module) ++ Name).
+
+params_name(Module) -> reg_name(Module, "_params").
+counts_name(Module) -> reg_name(Module, "_counters").
+manage_params_name(Module) -> reg_name(Module, "_params_mgr").
+manage_counts_name(Module) -> reg_name(Module, "_counters_mgr").
+
+
+start() ->
+ ok = application:start(syntax_tools),
+ ok = application:start(compiler),
+ ok = application:start(goldrush).
+
+%% @todo Move comment.
+%% @private Map a query to a simplified query tree term.
+%%
+%% The simplified query tree is used to combine multiple queries into one
+%% query module. The goal of this is to reduce the filtering and dispatch
+%% overhead when multiple concurrent queries are executed.
+%%
+%% A fixed selection condition may be used to specify a property that an event
+%% must have in order to be considered part of the input stream for a query.
+%%
+%% For the sake of simplicity it is only possible to define selection
+%% conditions using the fields present in the context and identifiers
+%% of an event. The fields in the context are bound to the reserved
+%% names:
+%%
+%% - '$n': node name
+%% - '$a': application name
+%% - '$p': process identifier
+%% - '$t': timestamp
+%% 
+%%
+%% If an event must be selected based on the runtime state of an event handler
+%% this must be done in the body of the handler.
+
+
+-ifdef(TEST).
+-include_lib("eunit/include/eunit.hrl").
+
+setup_query(Module, Query) ->
+ setup_query(Module, Query, undefined).
+
+setup_query(Module, Query, Store) ->
+ ?assertNot(erlang:module_loaded(Module)),
+ ?assertEqual({ok, Module}, case (catch compile(Module, Query, Store)) of
+ {'EXIT',_}=Error -> ?debugFmt("~p", [Error]), Error; Else -> Else end),
+ ?assert(erlang:function_exported(Module, table, 1)),
+ ?assert(erlang:function_exported(Module, handle, 1)),
+ {compiled, Module}.
+
+events_test_() ->
+ {foreach,
+ fun() ->
+ error_logger:tty(false),
+ application:start(syntax_tools),
+ application:start(compiler),
+ application:start(goldrush)
+ end,
+ fun(_) ->
+ application:stop(goldrush),
+ application:stop(compiler),
+ application:stop(syntax_tools),
+ error_logger:tty(true)
+ end,
+ [
+ {"null query compiles",
+ fun() ->
+ {compiled, Mod} = setup_query(testmod1, glc:null(false)),
+ ?assertError(badarg, Mod:table(noexists))
+ end
+ },
+ {"params table exists",
+ fun() ->
+ {compiled, Mod} = setup_query(testmod2, glc:null(false)),
+ ?assert(is_atom(Mod:table(params))),
+ ?assertMatch([_|_], gr_param:info(Mod:table(params)))
+ end
+ },
+ {"null query exists",
+ fun() ->
+ {compiled, Mod} = setup_query(testmod3, glc:null(false)),
+ ?assert(erlang:function_exported(Mod, info, 1)),
+ ?assertError(badarg, Mod:info(invalid)),
+ ?assertEqual({null, false}, Mod:info('query'))
+ end
+ },
+ {"init counters test",
+ fun() ->
+ {compiled, Mod} = setup_query(testmod4, glc:null(false)),
+ ?assertEqual(0, Mod:info(input)),
+ ?assertEqual(0, Mod:info(filter)),
+ ?assertEqual(0, Mod:info(output))
+ end
+ },
+ {"filtered events test",
+ fun() ->
+ %% If no selection condition is specified no inputs can match.
+ {compiled, Mod} = setup_query(testmod5, glc:null(false)),
+ glc:handle(Mod, gre:make([], [list])),
+ ?assertEqual(1, Mod:info(input)),
+ ?assertEqual(1, Mod:info(filter)),
+ ?assertEqual(0, Mod:info(output))
+ end
+ },
+ {"nomatch event test",
+ fun() ->
+ %% If a selection condition but no body is specified the event
+ %% is expected to count as filtered out if the condition does
+ %% not hold.
+ {compiled, Mod} = setup_query(testmod6, glc:eq('$n', 'noexists@nohost')),
+ glc:handle(Mod, gre:make([{'$n', 'noexists2@nohost'}], [list])),
+ ?assertEqual(1, Mod:info(input)),
+ ?assertEqual(1, Mod:info(filter)),
+ ?assertEqual(0, Mod:info(output))
+ end
+ },
+ {"opfilter equal test",
+ fun() ->
+ %% If a selection condition but no body is specified the event
+ %% counts as input to the query, but not as filtered out.
+ {compiled, Mod} = setup_query(testmod7a, glc:eq('$n', 'noexists@nohost')),
+ glc:handle(Mod, gre:make([{'$n', 'noexists@nohost'}], [list])),
+ ?assertEqual(1, Mod:info(input)),
+ ?assertEqual(0, Mod:info(filter)),
+ ?assertEqual(1, Mod:info(output))
+ end
+ },
+ {"opfilter not equal test",
+ fun() ->
+ {compiled, Mod} = setup_query(testmod7b, glc:neq('$n', 'noexists@nohost')),
+ glc:handle(Mod, gre:make([{'$n', 'noexists@nohost'}], [list])),
+ glc:handle(Mod, gre:make([{'$n', 'notexists@nohost'}], [list])),
+ ?assertEqual(2, Mod:info(input)),
+ ?assertEqual(1, Mod:info(filter)),
+ ?assertEqual(1, Mod:info(output))
+ end
+ },
+ {"opfilter wildcard test",
+ fun() ->
+ {compiled, Mod} = setup_query(testmod8, glc:wc(a)),
+ glc:handle(Mod, gre:make([{b, 2}], [list])),
+ ?assertEqual(1, Mod:info(input)),
+ ?assertEqual(1, Mod:info(filter)),
+ ?assertEqual(0, Mod:info(output)),
+ glc:handle(Mod, gre:make([{a, 2}], [list])),
+ ?assertEqual(2, Mod:info(input)),
+ ?assertEqual(1, Mod:info(filter)),
+ ?assertEqual(1, Mod:info(output))
+ end
+ },
+ {"opfilter notfound test",
+ fun() ->
+ {compiled, Mod} = setup_query(testmod9, glc:nf(a)),
+ glc:handle(Mod, gre:make([{a, 2}], [list])),
+ ?assertEqual(1, Mod:info(input)),
+ ?assertEqual(1, Mod:info(filter)),
+ ?assertEqual(0, Mod:info(output)),
+ glc:handle(Mod, gre:make([{b, 2}], [list])),
+ ?assertEqual(2, Mod:info(input)),
+ ?assertEqual(1, Mod:info(filter)),
+ ?assertEqual(1, Mod:info(output))
+ end
+ },
+ {"opfilter greater than test",
+ fun() ->
+ {compiled, Mod} = setup_query(testmod10a, glc:gt(a, 1)),
+ glc:handle(Mod, gre:make([{'a', 2}], [list])),
+ ?assertEqual(1, Mod:info(input)),
+ ?assertEqual(0, Mod:info(filter)),
+ glc:handle(Mod, gre:make([{'a', 0}], [list])),
+ ?assertEqual(2, Mod:info(input)),
+ ?assertEqual(1, Mod:info(filter)),
+ ?assertEqual(1, Mod:info(output))
+ end
+ },
+ {"opfilter greater than or equal to test",
+ fun() ->
+ {compiled, Mod} = setup_query(testmod10b, glc:gte(a, 1)),
+ glc:handle(Mod, gre:make([{'a', 2}], [list])),
+ ?assertEqual(1, Mod:info(input)),
+ ?assertEqual(0, Mod:info(filter)),
+ glc:handle(Mod, gre:make([{'a', 1}], [list])),
+ ?assertEqual(2, Mod:info(input)),
+ ?assertEqual(0, Mod:info(filter)),
+ glc:handle(Mod, gre:make([{'a', 0}], [list])),
+ ?assertEqual(3, Mod:info(input)),
+ ?assertEqual(1, Mod:info(filter)),
+ ?assertEqual(2, Mod:info(output))
+ end
+ },
+ {"opfilter less than test",
+ fun() ->
+ {compiled, Mod} = setup_query(testmod11a, glc:lt(a, 1)),
+ glc:handle(Mod, gre:make([{'a', 0}], [list])),
+ ?assertEqual(1, Mod:info(input)),
+ ?assertEqual(0, Mod:info(filter)),
+ ?assertEqual(1, Mod:info(output)),
+ glc:handle(Mod, gre:make([{'a', 2}], [list])),
+ ?assertEqual(2, Mod:info(input)),
+ ?assertEqual(1, Mod:info(filter)),
+ ?assertEqual(1, Mod:info(output))
+ end
+ },
+ {"opfilter less than or equal to test",
+ fun() ->
+ {compiled, Mod} = setup_query(testmod11b, glc:lte(a, 1)),
+ glc:handle(Mod, gre:make([{'a', 0}], [list])),
+ ?assertEqual(1, Mod:info(input)),
+ ?assertEqual(0, Mod:info(filter)),
+ ?assertEqual(1, Mod:info(output)),
+ glc:handle(Mod, gre:make([{'a', 1}], [list])),
+ ?assertEqual(2, Mod:info(input)),
+ ?assertEqual(0, Mod:info(filter)),
+ ?assertEqual(2, Mod:info(output)),
+ glc:handle(Mod, gre:make([{'a', 2}], [list])),
+ ?assertEqual(3, Mod:info(input)),
+ ?assertEqual(1, Mod:info(filter)),
+ ?assertEqual(2, Mod:info(output))
+ end
+ },
+ {"allholds op test",
+ fun() ->
+ {compiled, Mod} = setup_query(testmod12,
+ glc:all([glc:eq(a, 1), glc:eq(b, 2)])),
+ glc:handle(Mod, gre:make([{'a', 1}], [list])),
+ glc:handle(Mod, gre:make([{'a', 2}], [list])),
+ ?assertEqual(2, Mod:info(input)),
+ ?assertEqual(2, Mod:info(filter)),
+ glc:handle(Mod, gre:make([{'b', 1}], [list])),
+ glc:handle(Mod, gre:make([{'b', 2}], [list])),
+ ?assertEqual(4, Mod:info(input)),
+ ?assertEqual(4, Mod:info(filter)),
+ glc:handle(Mod, gre:make([{'a', 1},{'b', 2}], [list])),
+ ?assertEqual(5, Mod:info(input)),
+ ?assertEqual(4, Mod:info(filter)),
+ ?assertEqual(1, Mod:info(output))
+ end
+ },
+ {"anyholds op test",
+ fun() ->
+ {compiled, Mod} = setup_query(testmod13,
+ glc:any([glc:eq(a, 1), glc:eq(b, 2)])),
+ glc:handle(Mod, gre:make([{'a', 2}], [list])),
+ glc:handle(Mod, gre:make([{'b', 1}], [list])),
+ ?assertEqual(2, Mod:info(input)),
+ ?assertEqual(2, Mod:info(filter)),
+ glc:handle(Mod, gre:make([{'a', 1}], [list])),
+ glc:handle(Mod, gre:make([{'b', 2}], [list])),
+ ?assertEqual(4, Mod:info(input)),
+ ?assertEqual(2, Mod:info(filter))
+ end
+ },
+ {"with function test",
+ fun() ->
+ Self = self(),
+ {compiled, Mod} = setup_query(testmod14,
+ glc:with(glc:eq(a, 1), fun(Event) -> Self ! gre:fetch(a, Event) end)),
+ glc:handle(Mod, gre:make([{a,1}], [list])),
+ ?assertEqual(1, Mod:info(output)),
+ ?assertEqual(1, receive Msg -> Msg after 0 -> notcalled end)
+ end
+ },
+ {"with function storage test",
+ fun() ->
+ Self = self(),
+ Store = [{stored, value}],
+ {compiled, Mod} = setup_query(testmod15,
+ glc:with(glc:eq(a, 1), fun(Event, EStore) -> 
+ Self ! {gre:fetch(a, Event), EStore} end),
+ Store),
+ glc:handle(Mod, gre:make([{a,1}], [list])),
+ ?assertEqual(1, Mod:info(output)),
+ ?assertEqual(1, receive {Msg, Store} -> Msg after 0 -> notcalled end)
+ end
+ },
+ {"delete test",
+ fun() ->
+ {compiled, Mod} = setup_query(testmod16, glc:null(false)),
+ ?assert(is_atom(Mod:table(params))),
+ ?assertMatch([_|_], gr_param:info(Mod:table(params))),
+ ?assert(is_list(code:which(Mod))),
+ ?assert(is_pid(whereis(params_name(Mod)))),
+ ?assert(is_pid(whereis(counts_name(Mod)))),
+ ?assert(is_pid(whereis(manage_params_name(Mod)))),
+ ?assert(is_pid(whereis(manage_counts_name(Mod)))),
+
+ glc:delete(Mod),
+ 
+ ?assertEqual(non_existing, code:which(Mod)),
+ ?assertEqual(undefined, whereis(params_name(Mod))),
+ ?assertEqual(undefined, whereis(counts_name(Mod))),
+ ?assertEqual(undefined, whereis(manage_params_name(Mod))),
+ ?assertEqual(undefined, whereis(manage_counts_name(Mod)))
+ end
+ },
+ {"reset counters test",
+ fun() ->
+ {compiled, Mod} = setup_query(testmod17,
+ glc:any([glc:eq(a, 1), glc:eq(b, 2)])),
+ glc:handle(Mod, gre:make([{'a', 2}], [list])),
+ glc:handle(Mod, gre:make([{'b', 1}], [list])),
+ ?assertEqual(2, Mod:info(input)),
+ ?assertEqual(2, Mod:info(filter)),
+ glc:handle(Mod, gre:make([{'a', 1}], [list])),
+ glc:handle(Mod, gre:make([{'b', 2}], [list])),
+ ?assertEqual(4, Mod:info(input)),
+ ?assertEqual(2, Mod:info(filter)),
+ ?assertEqual(2, Mod:info(output)),
+
+ glc:reset_counters(Mod, input),
+ ?assertEqual(0, Mod:info(input)),
+ ?assertEqual(2, Mod:info(filter)),
+ ?assertEqual(2, Mod:info(output)),
+ glc:reset_counters(Mod, filter),
+ ?assertEqual(0, Mod:info(input)),
+ ?assertEqual(0, Mod:info(filter)),
+ ?assertEqual(2, Mod:info(output)),
+ glc:reset_counters(Mod),
+ ?assertEqual(0, Mod:info(input)),
+ ?assertEqual(0, Mod:info(filter)),
+ ?assertEqual(0, Mod:info(output))
+ end
+ },
+ {"ets data recovery test",
+ fun() ->
+ Self = self(),
+ {compiled, Mod} = setup_query(testmod18,
+ glc:with(glc:eq(a, 1), fun(Event) -> Self ! gre:fetch(a, Event) end)),
+ glc:handle(Mod, gre:make([{a,1}], [list])),
+ ?assertEqual(1, Mod:info(output)),
+ ?assertEqual(1, receive Msg -> Msg after 0 -> notcalled end),
+ ?assertEqual(1, length(gr_param:list(Mod:table(params)))),
+ ?assertEqual(7, length(gr_param:list(Mod:table(counters)))),
+ true = exit(whereis(Mod:table(params)), kill),
+ true = exit(whereis(Mod:table(counters)), kill),
+ ?assertEqual(1, Mod:info(input)),
+ glc:handle(Mod, gre:make([{'a', 1}], [list])),
+ ?assertEqual(2, Mod:info(input)),
+ ?assertEqual(2, Mod:info(output)),
+ ?assertEqual(1, length(gr_param:list(Mod:table(params)))),
+ ?assertEqual(7, length(gr_counter:list(Mod:table(counters))))
+ end
+ },
+ {"run timed job test",
+ fun() ->
+ Self = self(),
+ Store = [{stored, value}],
+ Runtime = 0.15,
+ {compiled, Mod} = setup_query(testmod19,
+ glc:gt(runtime, Runtime),
+ Store),
+ glc:run(Mod, fun(Event, EStore) -> 
+ timer:sleep(100),
+ Self ! {gre:fetch(a, Event), EStore}
+ end, gre:make([{a,1}], [list])),
+ ?assertEqual(0, Mod:info(output)),
+ ?assertEqual(1, Mod:info(filter)),
+ ?assertEqual(1, receive {Msg, Store} -> Msg after 0 -> notcalled end),
+
+ delete(testmod19),
+ {compiled, Mod} = setup_query(testmod19,
+ glc:gt(runtime, Runtime),
+ Store),
+ glc:handle(Mod, gre:make([{'a', 1}], [list])),
+ glc:run(Mod, fun(Event, EStore) -> 
+ timer:sleep(200),
+ Self ! {gre:fetch(a, Event), EStore}
+ end, gre:make([{a,2}], [list])),
+ ?assertEqual(1, Mod:info(output)),
+ ?assertEqual(1, Mod:info(filter)),
+ ?assertEqual(2, receive {Msg, Store} -> Msg after 0 -> notcalled end)
+
+ end
+ },
+ {"reset job counters",
+ fun() ->
+ {compiled, Mod} = setup_query(testmod20,
+ glc:any([glc:eq(a, 1), glc:gt(runtime, 0.15)])),
+ glc:handle(Mod, gre:make([{'a', 2}], [list])),
+ glc:handle(Mod, gre:make([{'b', 1}], [list])),
+ ?assertEqual(2, Mod:info(input)),
+ ?assertEqual(2, Mod:info(filter)),
+ glc:handle(Mod, gre:make([{'a', 1}], [list])),
+ glc:handle(Mod, gre:make([{'b', 2}], [list])),
+ ?assertEqual(4, Mod:info(input)),
+ ?assertEqual(3, Mod:info(filter)),
+ ?assertEqual(1, Mod:info(output)),
+
+ Self = self(),
+ glc:run(Mod, fun(Event, EStore) -> 
+ timer:sleep(100),
+ Self ! {gre:fetch(a, Event), EStore}
+ end, gre:make([{a,1}], [list])),
+ ?assertEqual(2, Mod:info(output)),
+ ?assertEqual(3, Mod:info(filter)),
+ ?assertEqual(1, receive {Msg, undefined} -> Msg after 0 -> notcalled end),
+
+ {_, Msg1} = glc:run(Mod, fun(_Event, _EStore) -> 
+ timer:sleep(200),
+ {error, badtest}
+ 
+ end, gre:make([{a,1}], [list])),
+ ?assertEqual(3, Mod:info(output)),
+ ?assertEqual(3, Mod:info(filter)),
+ ?assertEqual(2, Mod:info(job_input)),
+ ?assertEqual(1, Mod:info(job_error)),
+ ?assertEqual(1, Mod:info(job_run)),
+ ?assertEqual({error, badtest}, Msg1),
+
+ {_, Msg2} = glc:run(Mod, fun(_Event, _EStore) -> 
+ timer:sleep(20),
+ {ok, goodtest}
+ 
+ end, gre:make([{a,2}], [list])),
+ ?assertEqual(3, Mod:info(output)),
+ ?assertEqual(4, Mod:info(filter)),
+ ?assertEqual(3, Mod:info(job_input)),
+ ?assertEqual(1, Mod:info(job_error)),
+ ?assertEqual(2, Mod:info(job_run)),
+ ?assertEqual({ok, goodtest}, Msg2),
+
+
+ glc:reset_counters(Mod, input),
+ ?assertEqual(0, Mod:info(input)),
+ ?assertEqual(4, Mod:info(filter)),
+ ?assertEqual(3, Mod:info(output)),
+ ?assertEqual(3, Mod:info(job_input)),
+ ?assertEqual(1, Mod:info(job_error)),
+ ?assertEqual(2, Mod:info(job_run)),
+ glc:reset_counters(Mod, filter),
+ ?assertEqual(0, glc:input(Mod)),
+ ?assertEqual(0, glc:filter(Mod)),
+ ?assertEqual(3, glc:output(Mod)),
+ ?assertEqual(3, glc:job_input(Mod)),
+ ?assertEqual(1, glc:job_error(Mod)),
+ ?assertEqual(2, glc:job_run(Mod)),
+ glc:reset_counters(Mod, output),
+ ?assertEqual(0, Mod:info(input)),
+ ?assertEqual(0, Mod:info(filter)),
+ ?assertEqual(0, Mod:info(output)),
+ ?assertEqual(3, Mod:info(job_input)),
+ ?assertEqual(1, Mod:info(job_error)),
+ ?assertEqual(2, Mod:info(job_run)),
+ glc:reset_counters(Mod, job_input),
+ ?assertEqual(0, Mod:info(input)),
+ ?assertEqual(0, Mod:info(filter)),
+ ?assertEqual(0, Mod:info(output)),
+ ?assertEqual(0, Mod:info(job_input)),
+ ?assertEqual(1, Mod:info(job_error)),
+ ?assertEqual(2, Mod:info(job_run)),
+ glc:reset_counters(Mod, job_error),
+ ?assertEqual(0, Mod:info(input)),
+ ?assertEqual(0, Mod:info(filter)),
+ ?assertEqual(0, Mod:info(output)),
+ ?assertEqual(0, Mod:info(job_input)),
+ ?assertEqual(0, Mod:info(job_error)),
+ ?assertEqual(2, Mod:info(job_run)),
+ glc:reset_counters(Mod, job_run),
+ ?assertEqual(0, Mod:info(input)),
+ ?assertEqual(0, Mod:info(filter)),
+ ?assertEqual(0, Mod:info(output)),
+ ?assertEqual(0, Mod:info(job_input)),
+ ?assertEqual(0, Mod:info(job_error)),
+ ?assertEqual(0, Mod:info(job_run))
+ end
+ },
+ {"variable storage test",
+ fun() ->
+ {compiled, Mod} = setup_query(testmod20a,
+ glc:eq(a, 2), [{stream, time}]),
+ glc:handle(Mod, gre:make([{'a', 2}], [list])),
+ glc:handle(Mod, gre:make([{'b', 1}], [list])),
+ ?assertEqual(2, Mod:info(input)),
+ ?assertEqual(1, Mod:info(filter)),
+ glc:handle(Mod, gre:make([{'b', 2}], [list])),
+ ?assertEqual(3, Mod:info(input)),
+ ?assertEqual(2, Mod:info(filter)),
+ ?assertEqual({ok, time}, glc:get(Mod, stream)),
+ ?assertEqual({error, undefined}, glc:get(Mod, beam))
+ end
+ },
+ {"with multi function any test",
+ fun() ->
+ Self = self(),
+ Store = [{stored, value}],
+
+ G1 = glc:with(glc:eq(a, 1), fun(_Event, EStore) -> 
+ Self ! {a, EStore} end),
+ G2 = glc:with(glc:eq(b, 2), fun(_Event, EStore) -> 
+ Self ! {b, EStore} end),
+
+ {compiled, Mod} = setup_query(testmod20b, any([G1, G2]),
+ Store),
+ glc:handle(Mod, gre:make([{a,1}], [list])),
+ ?assertEqual(1, Mod:info(output)),
+ ?assertEqual(a, receive {Msg, _Store} -> Msg after 0 -> notcalled end),
+ ?assertEqual(b, receive {Msg, _Store} -> Msg after 0 -> notcalled end)
+ end
+ },
+ {"with multi function all test",
+ fun() ->
+ Self = self(),
+ Store = [{stored, value}],
+
+ G1 = glc:with(glc:eq(a, 1), fun(_Event, EStore) -> 
+ Self ! {a, EStore} end),
+ G2 = glc:with(glc:eq(b, 2), fun(_Event, EStore) -> 
+ Self ! {b, EStore} end),
+ G3 = glc:with(glc:eq(c, 3), fun(_Event, EStore) -> 
+ Self ! {c, EStore} end),
+
+ {compiled, Mod} = setup_query(testmod21, all([G1, G2, G3]),
+ Store),
+ glc:handle(Mod, gre:make([{a,1}], [list])),
+ ?assertEqual(0, Mod:info(output)),
+ ?assertEqual(1, Mod:info(filter)),
+ glc:handle(Mod, gre:make([{a,1}, {b, 2}], [list])),
+ ?assertEqual(0, Mod:info(output)),
+ ?assertEqual(2, Mod:info(filter)),
+ glc:handle(Mod, gre:make([{a,1}, {b, 2}, {c, 3}], [list])),
+ ?assertEqual(1, Mod:info(output)),
+ ?assertEqual(a, receive {Msg, _Store} -> Msg after 0 -> notcalled end),
+ ?assertEqual(b, receive {Msg, _Store} -> Msg after 0 -> notcalled end),
+ ?assertEqual(c, receive {Msg, _Store} -> Msg after 0 -> notcalled end)
+ end
+ },
+ {"with multi-function output match test",
+ fun() ->
+ Self = self(),
+ Store = [{stored, value}],
+
+ {compiled, Mod} = setup_query(testmod22,
+ [glc:with(glc:eq(a, 1), fun(Event, _EStore) -> 
+ Self ! {a, gre:fetch(a, Event)} end),
+ glc:with(glc:gt(b, 1), fun(Event, _EStore) -> 
+ Self ! {b, gre:fetch(b, Event)} end)],
+ Store),
+ glc:handle(Mod, gre:make([{a,1}, {b, 1}], [list])),
+ ?assertEqual(1, Mod:info(output)),
+ ?assertEqual(a, receive {a=Msg, _Store} -> Msg after 0 -> notcalled end)
+
+ end
+ },
+ {"with multi-function output double-match test",
+ fun() ->
+ Self = self(),
+ Store = [{stored, value}],
+ {compiled, Mod} = setup_query(testmod23,
+ [glc:with(glc:eq(a, 1), fun(Event, _EStore) -> 
+ Self ! {a, gre:fetch(a, Event)} end),
+ glc:with(glc:eq(b, 1), fun(Event, _EStore) -> 
+ Self ! {b, gre:fetch(b, Event)} end)],
+ Store),
+ glc:handle(Mod, gre:make([{a,1}, {b, 1}], [list])),
+ ?assertEqual(2, Mod:info(output)),
+ ?assertEqual(a, receive {a=Msg, _Store} -> Msg after 0 -> notcalled end),
+ ?assertEqual(b, receive {b=Msg, _Store} -> Msg after 0 -> notcalled end)
+ end
+ },
+ {"with multi function complex match test",
+ fun() ->
+ Self = self(),
+ Store = [{stored, value}],
+
+ G1 = glc:with(glc:gt(r, 0.1), fun(_Event, EStore) -> 
+ Self ! {a, EStore} end),
+ G2 = glc:with(glc:all([glc:eq(a, 1), glc:gt(r, 0.5)]), fun(_Event, EStore) -> 
+ Self ! {b, EStore} end),
+ G3 = glc:with(glc:all([glc:eq(a, 1), glc:eq(b, 2), glc:gt(r, 0.6)]), fun(_Event, EStore) -> 
+ Self ! {c, EStore} end),
+
+ {compiled, Mod} = setup_query(testmod24, [G1, G2, G3],
+ Store),
+ glc:handle(Mod, gre:make([{a,1}, {r, 0.7}, {b, 3}], [list])),
+ ?assertEqual(2, Mod:info(output)),
+ ?assertEqual(1, Mod:info(input)),
+ ?assertEqual(1, Mod:info(filter)),
+ ?assertEqual(a, receive {Msg, _Store} -> Msg after 0 -> notcalled end),
+ ?assertEqual(b, receive {Msg, _Store} -> Msg after 0 -> notcalled end),
+ %
+ glc:handle(Mod, gre:make([{a,1}, {r, 0.6}], [list])),
+ ?assertEqual(4, Mod:info(output)),
+ ?assertEqual(2, Mod:info(input)),
+ ?assertEqual(2, Mod:info(filter)),
+ ?assertEqual(a, receive {Msg, _Store} -> Msg after 0 -> notcalled end),
+ ?assertEqual(b, receive {Msg, _Store} -> Msg after 0 -> notcalled end),
+ %
+ glc:handle(Mod, gre:make([{a,2}, {r, 0.7}, {b, 3}], [list])),
+ ?assertEqual(5, Mod:info(output)),
+ ?assertEqual(3, Mod:info(input)),
+ ?assertEqual(4, Mod:info(filter)),
+ ?assertEqual(a, receive {Msg, _Store} -> Msg after 0 -> notcalled end),
+
+ glc:handle(Mod, gre:make([{a,1}, {r, 0.7}, {b, 2}], [list])),
+ ?assertEqual(8, Mod:info(output)),
+ ?assertEqual(4, Mod:info(input)),
+ ?assertEqual(4, Mod:info(filter)),
+ ?assertEqual(a, receive {Msg, _Store} -> Msg after 0 -> notcalled end),
+ ?assertEqual(b, receive {Msg, _Store} -> Msg after 0 -> notcalled end),
+ ?assertEqual(c, receive {Msg, _Store} -> Msg after 0 -> notcalled end)
+ end
+ },
+ {"with single-function run test",
+ fun() ->
+ Self = self(),
+ Store = [{stored, value}],
+ {compiled, Mod1} = setup_query(testmod25a,
+ glc:with(glc:all([glc:gt(runtime, 0.15), glc:lt(a, 3)]), fun(Event, EStore) -> 
+ Self ! {gre:fetch(a, Event), EStore} end),
+ Store),
+ glc:run(Mod1, fun(_Event, _EStore) -> timer:sleep(200), ok end, gre:make([{a, 2}], [list])),
+ ?assertEqual(1, Mod1:info(output)),
+ ?assertEqual(2, receive {Msg, Store} -> Msg after 250 -> notcalled end),
+ {compiled, Mod2} = setup_query(testmod25b,
+ glc:with(glc:all([glc:gt(runtime, 0.15), glc:lt(a, 3)]), fun(Event, EStore) -> 
+ Self ! {gre:fetch(a, Event), EStore}
+ end), Store),
+ {_, {error, later}} = glc:run(Mod2, fun(_Event, _EStore) -> 
+ timer:sleep(200), 
+ erlang:exit(later)
+ end, gre:make([{a, 2}], [list])),
+ ?assertEqual(1, Mod2:info(output)),
+ ?assertEqual(1, Mod2:info(job_error)),
+ ?assertEqual(2, receive {Msg, Store} -> Msg after 250 -> notcalled end)
+ end
+ },
+ {"with multi-function output run error test",
+ fun() ->
+ Self = self(),
+ Store = [{stored, value}],
+ {compiled, Mod} = setup_query(testmod26,
+ [glc:with(glc:gt(runtime, 0.15), fun(Event, _EStore) -> 
+ Self ! {a, gre:fetch(b, Event)} 
+ end),
+ glc:with(glc:eq(c, 3), fun(Event, _EStore) -> 
+ Self ! {a, gre:fetch(a, Event)} 
+ end),
+ glc:with(glc:eq(b, 3), fun(Event, _EStore) -> 
+ Self ! {a, gre:fetch(a, Event)} 
+ end),
+ glc:with(glc:eq(a, 1), fun(Event, _EStore) -> 
+ receive {a, _Store} -> 
+ Self ! {b, gre:fetch(b, Event)}
+ after 10 -> notcalled end
+ end)
+ ],
+ Store),
+ Event = gre:make([{a,1}, {b, 3}, {c, 4}], [list]),
+ {_, {error, bye}} = glc:run(Mod, fun(_Event, _EStore) -> 
+ timer:sleep(200),
+ erlang:error(bye) 
+ end, Event),
+ ?assertEqual(3, Mod:info(output)),
+ ?assertEqual(1, Mod:info(filter)),
+ ?assertEqual(1, Mod:info(job_error)),
+ ?assertEqual(b, receive {b=Msg, _Store} -> Msg after 0 -> notcalled end)
+ end
+ }
+ ]
+ }.
+
+union_error_test() ->
+ ?assertError(badarg, glc:union([glc:eq(a, 1)])),
+ done.
+
+-endif.

guam-0.9.11.tar.gz/_checkouts/goldrush/src/glc_code.erl Added

@@ -0,0 +1,624 @@
+%% @doc Code generation functions.
+-module(glc_code).
+-compile({nowarn_unused_function, {abstract_module,2}}).
+-compile({nowarn_unused_function, {abstract_tables,1}}).
+-compile({nowarn_unused_function, {abstract_reset,0}}).
+-compile({nowarn_unused_function, {abstract_filter,3}}).
+-compile({nowarn_unused_function, {abstract_filter_,4}}).
+-compile({nowarn_unused_function, {abstract_opfilter,6}}).
+-compile({nowarn_unused_function, {abstract_all,4}}).
+-compile({nowarn_unused_function, {abstract_any,4}}).
+-compile({nowarn_unused_function, {abstract_with,3}}).
+-compile({nowarn_unused_function, {abstract_within,3}}).
+-compile({nowarn_unused_function, {abstract_getkey,4}}).
+-compile({nowarn_unused_function, {abstract_getkey_,4}}).
+-compile({nowarn_unused_function, {abstract_getparam,3}}).
+-compile({nowarn_unused_function, {param_variable,1}}).
+-compile({nowarn_unused_function, {field_variable,1}}).
+-compile({nowarn_unused_function, {field_variable_,1}}).
+-compile({nowarn_unused_function, {compile_forms,2}}).
+-compile({nowarn_unused_function, {load_binary,2}}).
+
+
+-export([
+ compile/2
+]).
+
+-define(erl, erl_syntax).
+
+-record(module, {
+ 'query' :: term(),
+ tables :: [{atom(), atom()}],
+ qtree :: term(),
+ store :: term()
+}).
+
+-type syntaxTree() :: erl_syntax:syntaxTree().
+
+-record(state, {
+ event = undefined :: syntaxTree(),
+ fields = [] :: [{atom(), syntaxTree()}],
+ fieldc = 0 :: non_neg_integer(),
+ paramvars = [] :: [{term(), syntaxTree()}],
+ paramstab = undefined :: atom(),
+ countstab = undefined :: atom()
+}).
+
+-type nextFun() :: fun((#state{}) -> [syntaxTree()]).
+
+compile(Module, ModuleData) ->
+ {ok, forms, Forms} = abstract_module(Module, ModuleData),
+ {ok, Module, Binary} = compile_forms(Forms, [nowarn_unused_vars]),
+ {ok, loaded, Module} = load_binary(Module, Binary),
+ {ok, Module}.
+
+%% abstract code generation functions
+
+%% @private Generate an abstract dispatch module.
+-spec abstract_module(atom(), #module{}) -> {ok, forms, list()}.
+abstract_module(Module, Data) ->
+ Forms = [?erl:revert(E) || E <- abstract_module_(Module, Data)],
+ case lists:keyfind(errors, 1, erl_syntax_lib:analyze_forms(Forms)) of
+ false -> {ok, forms, Forms};
+ {_, []} -> {ok, forms, Forms};
+ {_, [_|_]}=Errors -> Errors
+ end.
+
+%% @private Generate an abstract dispatch module.
+-spec abstract_module_(atom(), #module{}) -> [?erl:syntaxTree()].
+abstract_module_(Module, #module{tables=Tables, 
+ qtree=Tree, store=Store}=Data) ->
+ {_, ParamsTable} = lists:keyfind(params, 1, Tables),
+ {_, CountsTable} = lists:keyfind(counters, 1, Tables),
+ AbstractMod = [
+ %% -module(Module)
+ ?erl:attribute(?erl:atom(module), [?erl:atom(Module)]),
+ %% -export([
+ ?erl:attribute(
+ ?erl:atom(export),
+ [?erl:list([
+ %% get/1
+ ?erl:arity_qualifier(
+ ?erl:atom(get),
+ ?erl:integer(1)),
+ %% info/1
+ ?erl:arity_qualifier(
+ ?erl:atom(info),
+ ?erl:integer(1)),
+ %% reset_counters/1
+ ?erl:arity_qualifier(
+ ?erl:atom(reset_counters),
+ ?erl:integer(1)),
+ %% table/1
+ ?erl:arity_qualifier(
+ ?erl:atom(table),
+ ?erl:integer(1)),
+ ?erl:arity_qualifier(
+ ?erl:atom(runjob),
+ ?erl:integer(2)),
+ %% handle/1
+ ?erl:arity_qualifier(
+ ?erl:atom(handle),
+ ?erl:integer(1))])]),
+ %% ]).
+ %% get(Name) -> Term.
+ ?erl:function(
+ ?erl:atom(get),
+ abstract_get(Data) ++
+ [?erl:clause(
+ [?erl:underscore()], none,
+ [?erl:abstract({error, undefined})])]),
+ %% info(Name) -> Term.
+ ?erl:function(
+ ?erl:atom(info),
+ abstract_info(Data) ++
+ [?erl:clause(
+ [?erl:underscore()], none,
+ [abstract_apply(erlang, error, [?erl:atom(badarg)])])]),
+ %% reset_counters(Name) -> boolean().
+ ?erl:function(
+ ?erl:atom(reset_counters),
+ abstract_reset() ++
+ [?erl:clause(
+ [?erl:underscore()], none,
+ [abstract_apply(erlang, error, [?erl:atom(badarg)])])]),
+ %% table(Name) -> atom().
+ ?erl:function(
+ ?erl:atom(table),
+ abstract_tables(Tables) ++
+ [?erl:clause(
+ [?erl:underscore()], none,
+ [abstract_apply(erlang, error, [?erl:atom(badarg)])])]),
+ %% handle(Event) - entry function
+ ?erl:function(
+ ?erl:atom(handle),
+ [?erl:clause([?erl:variable("Event")], none,
+ [abstract_count(input),
+ ?erl:application(none,
+ ?erl:atom(handle_), [?erl:variable("Event")])])]),
+ ?erl:function(
+ ?erl:atom(runjob),
+ [?erl:clause([?erl:variable("Fun"), ?erl:variable("Event")], none,
+ [abstract_count(job_input),
+ ?erl:application(none,
+ ?erl:atom(job_), [?erl:variable("Fun"),
+ ?erl:variable("Event")])])]),
+ %% input_(Node, App, Pid, Tags, Values) - filter roots
+ ?erl:function(
+ ?erl:atom(handle_),
+ [?erl:clause([?erl:variable("Event")], none,
+ abstract_filter(Tree, Data, #state{
+ event=?erl:variable("Event"),
+ paramstab=ParamsTable,
+ countstab=CountsTable}))]),
+ ?erl:function(
+ ?erl:atom(job_),
+ [?erl:clause([?erl:variable("Fun"),
+ ?erl:variable("Meta")], none,
+
+ [?erl:application(none,
+ ?erl:atom(job_result), [
+ ?erl:catch_expr(
+ abstract_apply(glc_run, execute, [
+ ?erl:variable("Fun"),
+ ?erl:list([?erl:variable("Meta"), 
+ ?erl:abstract(Store)])
+ ])),
+ ?erl:variable("Meta")])
+ ] 
+ )]),
+ ?erl:function(
+ ?erl:atom(job_result),
+ abstract_runjob(Data)
+ )
+ ],
+ %% Transform Term -> Key to Key -> Term
+ gr_param:transform(ParamsTable),
+ AbstractMod.
+
+%% @private Return the clauses of the table/1 function.
+abstract_tables(Tables) ->
+ [?erl:clause(
+ [?erl:abstract(K)], none,
+ [?erl:abstract(V)])
+ || {K, V} <- Tables].
+
+abstract_query_find(K, Store) ->
+ case lists:keyfind(K, 1, Store) of
+ {_, Val} -> 
+ {ok, Val};
+ _ -> 
+ {error, notfound}
+ end.
+
+%% @private Return the original query as an expression.
+abstract_query({with, Query, _}) ->
+ [?erl:abstract(Query)];
+abstract_query([{with, _Query, _}|_] = I) ->
+ [?erl:abstract([Query || {with, Query, _} <- I])];
+ %[?erl:abstract(_Query)];
+abstract_query({any, [{with, _Q, _A}|_] = I}) ->
+ Queries = glc_lib:reduce(glc:any([Q || {with, Q, _} <- I])),
+ [?erl:abstract(Queries)];
+abstract_query({all, [{with, _Q, _A}|_] = I}) ->
+ Queries = glc_lib:reduce(glc:all([Q || {with, Q, _} <- I])),
+ [?erl:abstract(Queries)];
+abstract_query(Query) ->
+ [?erl:abstract(Query)].
+
+
+%% @private Return the clauses of the get/1 function.
+abstract_get(#module{'query'=_Query, store=undefined}) ->
+ [];
+abstract_get(#module{'query'=_Query, store=Store}) ->
+ [?erl:clause([?erl:abstract(K)], none, 
+ abstract_query(abstract_query_find(K, Store)))
+ || {K, _} <- Store].
+
+%% @private 
+abstract_runjob(#module{'query'=_Query, store=_Store}) ->
+ Time = abstract_apply(erlang, '/', [?erl:variable("Time"),
+ ?erl:abstract(1000000)]),
+ [?erl:clause([?erl:variable("JobResult"),
+ ?erl:variable("Meta")], none,
+ [
+ ?erl:case_expr(?erl:variable("JobResult"),
+ [
+ ?erl:clause(
+ [?erl:tuple([?erl:variable("Time"), ?erl:variable("Result")])],
+ none,
+ [?erl:case_expr(?erl:variable("Result"),
+ [
+ ?erl:clause(
+ [?erl:tuple([?erl:atom(error),?erl:variable("Reason")])],
+ none,
+ [abstract_count(input), abstract_count(job_error),
+ ?erl:application(none, ?erl:atom(handle_), 
+ abstract_job(Time, [?erl:tuple([?erl:atom(error), 
+ ?erl:variable("Reason")])])),
+ abstract_count(job_time, ?erl:variable("Time")),
+ ?erl:tuple([?erl:variable("Time"), 
+ ?erl:tuple([?erl:atom(error), 
+ ?erl:variable("Reason")])])]),
+
+ ?erl:clause(
+ [?erl:variable("Result")],
+ none,
+ [abstract_count(input), abstract_count(job_run),
+ ?erl:application(none, ?erl:atom(handle_), 
+ abstract_job(Time)),
+ abstract_count(job_time, ?erl:variable("Time")),
+ ?erl:tuple([?erl:variable("Time"), 
+ ?erl:variable("Result")])])
+ ])
+ ])
+ ])
+ ]
+ )].
+
+abstract_job(Time) ->
+ abstract_job(Time, []).
+abstract_job(Time, Error) ->
+ Pairs = abstract_apply(gre, pairs, [?erl:variable("Meta")]),
+ Runtime = ?erl:list([?erl:tuple([?erl:atom(runtime), Time])]),
+ [abstract_apply(gre, make, 
+ [abstract_apply(erlang, '++', [?erl:list(Error), 
+ abstract_apply(erlang, '++', [Pairs, Runtime])]),
+ ?erl:abstract([list])])].
+
+%% @private Return the clauses of the info/1 function.
+abstract_info(#module{'query'=Query}) ->
+ [?erl:clause([?erl:abstract(K)], none, V)
+ || {K, V} <- [
+ {'query', abstract_query(Query)},
+ {input, abstract_getcount(input)},
+ {filter, abstract_getcount(filter)},
+ {output, abstract_getcount(output)},
+ {job_input, abstract_getcount(job_input)},
+ {job_run, abstract_getcount(job_run)},
+ {job_time, abstract_getcount(job_time)},
+ {job_error, abstract_getcount(job_error)}
+ ]].
+
+
+abstract_reset() ->
+ [?erl:clause([?erl:abstract(K)], none, V)
+ || {K, V} <- [
+ {all, abstract_resetcount([input, filter, output, 
+ job_input, job_run, 
+ job_time, job_error])},
+ {input, abstract_resetcount(input)},
+ {filter, abstract_resetcount(filter)},
+ {output, abstract_resetcount(output)},
+ {job_input, abstract_resetcount(job_input)},
+ {job_run, abstract_resetcount(job_run)},
+ {job_time, abstract_resetcount(job_time)},
+ {job_error, abstract_resetcount(job_error)}
+ ]].
+
+
+%% @private Return a list of expressions to apply a filter.
+%% @todo Allow mulitple functions to be specified using `with/2'.
+-spec abstract_filter(glc_ops:op() | [glc_ops:op()], #module{}, #state{}) -> [syntaxTree()].
+abstract_filter({Type, [{with, _Cond, _Fun}|_] = I}, Data, State) when Type =:= all; Type =:= any ->
+ Cond = glc_lib:reduce(glc:Type([Q || {with, Q, _} <- I])),
+ abstract_filter_(Cond,
+ _OnMatch=fun(State2) ->
+ Funs = [ F || {with, _, F} <- I ],
+ [abstract_count(output)] ++ 
+ abstract_with(Funs, Data, State2) end,
+ _OnNomatch=fun(_State2) -> [abstract_count(filter)] end, State);
+abstract_filter([{with, _Cond, _Fun}|_] = I, Data, State) ->
+ OnNomatch = fun(_State2) -> [abstract_count(filter, 0)] end,
+ Funs = lists:foldr(fun({with, Cond, Fun}, Acc) -> 
+ [{Cond, Fun, Data}|Acc]
+ end, [], I),
+ abstract_within(Funs, OnNomatch, State);
+abstract_filter({with, Cond, Fun}, Data, State) ->
+ abstract_filter_(Cond,
+ _OnMatch=fun(State2) ->
+ [abstract_count(output)] ++ 
+ abstract_with(Fun, Data, State2) end,
+ _OnNomatch=fun(_State2) -> [abstract_count(filter)] end, State);
+abstract_filter(Cond, _Data, State) ->
+ abstract_filter_(Cond,
+ _OnMatch=fun(_State2) -> [abstract_count(output)] end,
+ _OnNomatch=fun(_State2) -> [abstract_count(filter)] end, State).
+
+%% @private Return a list of expressions to apply a filter.
+%% A filter expects two continuation functions which generates the expressions
+%% to apply when the filter matches or fails to match. The state passed to the
+%% functions will contain all the variable bindings of previously accessed
+%% fields and parameters.
+-spec abstract_filter_(glc_ops:op(), nextFun(), nextFun(), #state{}) ->
+ syntaxTree().
+abstract_filter_({null, true}, OnMatch, _OnNomatch, State) ->
+ OnMatch(State);
+abstract_filter_({null, false}, _OnMatch, OnNomatch, State) ->
+ OnNomatch(State);
+abstract_filter_({Key, '*'}, OnMatch, OnNomatch, State) ->
+ abstract_getkey(Key,
+ _OnMatch=fun(#state{}=State2) -> OnMatch(State2) end,
+ _OnNomatch=fun(State2) -> OnNomatch(State2) end, State);
+abstract_filter_({Key, '!'}, OnMatch, OnNomatch, State) ->
+ abstract_getkey(Key,
+ _OnNomatch=fun(State2) -> OnNomatch(State2) end, 
+ _OnMatch=fun(#state{}=State2) -> OnMatch(State2) end,
+ State);
+abstract_filter_({Key, Op, Value}, OnMatch, OnNomatch, State)
+ when Op =:= '>'; Op =:= '='; Op =:= '!='; Op =:= '<';
+ Op =:= '>='; Op =:= '=<'; Op =:= '<=' ->
+ Op2 = case Op of 
+ '=' -> '=:='; 
+ '!=' -> '=/='; 
+ '<=' -> '=<';
+ Op -> Op 
+ end,
+ abstract_opfilter(Key, Op2, Value, OnMatch, OnNomatch, State);
+abstract_filter_({'any', Conds}, OnMatch, OnNomatch, State) ->
+ abstract_any(Conds, OnMatch, OnNomatch, State);
+abstract_filter_({'all', Conds}, OnMatch, OnNomatch, State) ->
+ abstract_all(Conds, OnMatch, OnNomatch, State).
+
+%% @private Return a branch based on a built in operator.
+-spec abstract_opfilter(atom(), atom(), term(), nextFun(),
+ nextFun(), #state{}) -> [syntaxTree()].
+abstract_opfilter(Key, Opname, Value, OnMatch, OnNomatch, State) ->
+ abstract_getkey(Key,
+ _OnMatch=fun(#state{}=State2) ->
+ [?erl:case_expr(
+ abstract_apply(erlang, Opname, [
+ ?erl:variable(field_variable(Key)),
+ ?erl:abstract(Value)
+ ]),
+ [?erl:clause([?erl:atom(true)], none, 
+ OnMatch(State2)),
+ ?erl:clause([?erl:atom(false)], none,
+ OnNomatch(State2))])] end,
+ _OnNomatch=fun(State2) -> OnNomatch(State2) end, State).
+
+%% @private Generate an `all' filter.
+%% An `all' filter is evaluated by testing all conditions that must hold. If
+%% any of the conditions does not hold the evaluation is short circuted at that
+%% point. This means that the `OnNomatch' branch is executed once for each
+%% condition. The `OnMatch' branch is only executed once.
+-spec abstract_all([glc_ops:op()], nextFun(), nextFun(), #state{}) ->
+ [syntaxTree()].
+abstract_all([H|T], OnMatch, OnNomatch, State) ->
+ abstract_filter_(H,
+ _OnMatch=fun(State2) -> abstract_all(T, OnMatch, OnNomatch, State2)
+ end, OnNomatch, State);
+abstract_all([], OnMatch, _OnNomatch, State) ->
+ OnMatch(State).
+
+%% @private
+-spec abstract_any([glc_ops:op()], nextFun(), nextFun(), #state{}) ->
+ [syntaxTree()].
+abstract_any([H|T], OnMatch, OnNomatch, State) ->
+ abstract_filter_(H, OnMatch,
+ _OnNomatch=fun(State2) -> abstract_any(T, OnMatch, OnNomatch, State2)
+ end, State);
+abstract_any([], _OnMatch, OnNomatch, State) ->
+ OnNomatch(State).
+
+%% @private
+-spec abstract_with(fun((gre:event()) -> term()), 
+ #module{}, #state{}) -> [syntaxTree()].
+abstract_with([Fun0|_] = Funs, Data, State) 
+ when is_function(Fun0, 1); is_function(Fun0, 2) ->
+ abstract_getparam(Funs, fun(#state{event=Event, paramvars=Params}) ->
+ lists:map(fun(Fun) -> 
+ {_, Fun2} = lists:keyfind(Fun, 1, Params),
+ abstract_with_({Fun, Fun2}, Event, Data)
+ end, Funs)
+ end, State);
+abstract_with(Fun, Data, State) when is_function(Fun, 1); is_function(Fun, 2) ->
+ abstract_getparam(Fun, fun(#state{event=Event, paramvars=Params}) ->
+ {_, Fun2} = lists:keyfind(Fun, 1, Params),
+ [abstract_with_({Fun, Fun2}, Event, Data)]
+ end, State).
+
+abstract_within([{H, Fun, Data}|T], OnNomatch, State) ->
+ OnMatch = fun(State2) -> [abstract_count(output)] ++ 
+ abstract_with(Fun, Data, State2) 
+ ++ abstract_within(T, OnNomatch, State2)
+ end,
+ abstract_filter_(H, OnMatch,
+ _OnNomatch=fun(State2) -> 
+ [abstract_count(filter)] ++ 
+ abstract_within(T, OnNomatch, State2)
+ end, State);
+abstract_within([], OnNomatch, State) ->
+ OnNomatch(State).
+
+abstract_with_({Fun, Fun2}, Event, #module{store=Store}) ->
+ ?erl:application(none, Fun2, 
+ case Fun of
+ _ when is_function(Fun, 1) ->
+ [Event];
+ _ when is_function(Fun, 2) ->
+ [Event, ?erl:abstract(Store)]
+ end).
+
+%% @private Bind the value of a field to a variable.
+%% If the value of a field has already been bound to a variable the previous
+%% binding is reused over re-accessing the value. The `OnMatch' function is
+%% expected to access the variable stored in the state record. The `OnNomatch'
+%% function must not attempt to access the variable.
+-spec abstract_getkey(atom(), nextFun(), nextFun(), #state{}) ->
+ [syntaxTree()].
+abstract_getkey(Key, OnMatch, OnNomatch, #state{fields=Fields}=State) ->
+ case lists:keyfind(Key, 1, Fields) of
+ {Key, _Variable} -> OnMatch(State);
+ false -> abstract_getkey_(Key, OnMatch, OnNomatch, State)
+ end.
+
+
+-spec abstract_getkey_(atom(), nextFun(), nextFun(), #state{}) ->
+ [syntaxTree()].
+abstract_getkey_(Key, OnMatch, OnNomatch, #state{
+ event=Event, fields=Fields}=State) ->
+ [?erl:case_expr(
+ abstract_apply(gre, find, [?erl:atom(Key), Event]),
+ [?erl:clause([
+ ?erl:tuple([
+ ?erl:atom(true),
+ ?erl:variable(field_variable(Key))])], none,
+ OnMatch(State#state{
+ fields=[{Key, ?erl:variable(field_variable(Key))}
+ |Fields]})),
+ ?erl:clause([
+ ?erl:atom(false)], none,
+ OnNomatch(State))
+ ]
+ )].
+
+%% @private Bind the value of a parameter to a variable.
+%% During code generation the parameter value is used as the identity of the
+%% parameter. At runtime a unique integer is used as the identity.
+-spec abstract_getparam(term(), nextFun(), #state{}) -> [syntaxTree()].
+abstract_getparam([_|_]=Terms, OnBound, #state{paramvars=_Params, fields=_Fields,
+ paramstab=_ParamsTable}=State) 
+ when is_list(Terms) ->
+
+ {Keys, Bound} = lists:foldl(fun(Term, {Acc0, #state{paramvars=Params,
+ paramstab=ParamsTable}=State0}) ->
+ case lists:keyfind(Term, 1, Params) of
+ {_, _Variable} -> 
+ {Acc0, State0};
+
+ false ->
+ Key = abstract_getparam_key(Term, ParamsTable),
+ Lookup = abstract_apply(gr_param, lookup_element,
+ [abstract_apply(table, [?erl:atom(params)]),
+ ?erl:abstract(Key)]),
+ Expr = ?erl:match_expr(param_variable(Key), Lookup),
+ State1 = State0#state{paramvars=[{Term, param_variable(Key)}|Params]},
+ {[Expr|Acc0], State1}
+
+ end
+ end, {[], State}, Terms),
+ Keys ++ OnBound(Bound);
+abstract_getparam(Term, OnBound, #state{paramvars=Params}=State) ->
+ case lists:keyfind(Term, 1, Params) of
+ {_, _Variable} -> OnBound(State);
+ %% parameter not bound to variable in this scope.
+ false -> abstract_getparam([Term], OnBound, State)
+ end.
+
+abstract_getparam_key(Term, ParamsTable) ->
+ case gr_param:lookup(ParamsTable, Term) of
+ [{_, Key2}] ->
+ Key2;
+ [] ->
+ Key2 = gr_param:info_size(ParamsTable),
+ gr_param:insert(ParamsTable, {Term, Key2}),
+ Key2
+ end.
+
+%% @private Generate a variable name for the value of a field.
+-spec field_variable(atom()) -> string().
+field_variable(Key) ->
+ "Field_" ++ field_variable_(atom_to_list(Key)).
+
+%% @private Escape non-alphanumeric values.
+-spec field_variable_(string()) -> string().
+field_variable_([H|T]) when H >= $0, H =< $9 ->
+ [H|field_variable_(T)];
+field_variable_([H|T]) when H >= $A, H =< $Z ->
+ [H|field_variable_(T)];
+field_variable_([H|T]) when H >= $a, H =< $z ->
+ [H|field_variable_(T)];
+field_variable_([H|T]) ->
+ "_" ++ integer_to_list(H, 16) ++ "_" ++ field_variable_(T);
+field_variable_([]) ->
+ [].
+
+%% @private Generate a variable name for the value of a parameter.
+-spec param_variable(integer()) -> syntaxTree().
+param_variable(Key) ->
+ ?erl:variable("Param_" ++ integer_to_list(Key)).
+
+%% @ private Generate a list of field variable names.
+%% Walk the query tree and generate a safe variable name string for each field
+%% that is accessed by the conditions in the query. Only allow alpha-numeric.
+%%-spec field_variables(glc_ops:op()) -> [{atom(), string()}].
+%%field_variables(Query) ->
+%% lists:usort(field_variables_(Query)).
+
+%%-spec field_variables(glc_ops:op()) -> [{atom(), string()}].
+%%field_variables_({Key, '=', _Term}) ->
+%% [{Key, field_variable(Key)}].
+
+
+
+%% @private Return an expression to increment a counter.
+%% @todo Pass state record. Only Generate code if `statistics' is enabled.
+-spec abstract_count(atom()) -> syntaxTree().
+abstract_count(Counter) ->
+ abstract_count(Counter, 1).
+abstract_count(Counter, Value) when is_integer(Value) ->
+ abstract_apply(gr_counter, update_counter,
+ [abstract_apply(table, [?erl:atom(counters)]),
+ ?erl:abstract(Counter),
+ ?erl:abstract({2,Value})]);
+abstract_count(Counter, Value) ->
+ abstract_apply(gr_counter, update_counter,
+ [abstract_apply(table, [?erl:atom(counters)]),
+ ?erl:abstract(Counter),
+ ?erl:tuple([?erl:abstract(2), Value])
+ ]).
+
+
+%% @private Return an expression to get the value of a counter.
+%% @todo Pass state record. Only Generate code if `statistics' is enabled.
+-spec abstract_getcount(atom()) -> [syntaxTree()].
+abstract_getcount(Counter) when is_atom(Counter) ->
+ abstract_getcount(?erl:abstract(Counter));
+abstract_getcount(Counter) ->
+ [abstract_apply(gr_counter, lookup_element,
+ [abstract_apply(table, [?erl:atom(counters)]), Counter])].
+
+%% @private Return an expression to reset a counter.
+-spec abstract_resetcount(atom() | [filter | input | output | 
+ job_input | job_run | job_time | job_error ]) 
+ -> [syntaxTree()].
+abstract_resetcount(Counter) ->
+ [abstract_apply(gr_counter, reset_counters,
+ [abstract_apply(table, [?erl:atom(counters)]),
+ ?erl:abstract(Counter)])].
+
+
+
+%% abstract code util functions
+
+
+%% @private Compile an abstract module.
+-spec compile_forms(term(), [term()]) -> {ok, atom(), binary()}.
+compile_forms(Forms, Opts) ->
+ case compile:forms(Forms, Opts) of
+ {ok, Module, Binary} ->
+ {ok, Module, Binary};
+ {ok, Module, Binary, _Warnings} ->
+ {ok, Module, Binary};
+ Error ->
+ erlang:error({compile_forms, Error})
+ end.
+
+%% @private Load a module binary.
+-spec load_binary(atom(), binary()) -> {ok, loaded, atom()}.
+load_binary(Module, Binary) ->
+ case code:load_binary(Module, "", Binary) of
+ {module, Module} -> {ok, loaded, Module};
+ {error, Reason} -> exit({error_loading_module, Module, Reason})
+ end.
+
+%% @private Apply an exported function.
+-spec abstract_apply(atom(), atom(), [syntaxTree()]) -> syntaxTree().
+abstract_apply(Module, Function, Arguments) ->
+ ?erl:application(?erl:atom(Module), ?erl:atom(Function), Arguments).
+
+%% @private Apply a module local function.
+-spec abstract_apply(atom(), [syntaxTree()]) -> syntaxTree().
+abstract_apply(Function, Arguments) ->
+ ?erl:application(?erl:atom(Function), Arguments).

guam-0.9.11.tar.gz/_checkouts/goldrush/src/glc_lib.erl Added

@@ -0,0 +1,451 @@
+%% Copyright (c) 2012, Magnus Klaar <klaar@ninenines.eu>
+%%
+%% Permission to use, copy, modify, and/or distribute this software for any
+%% purpose with or without fee is hereby granted, provided that the above
+%% copyright notice and this permission notice appear in all copies.
+%%
+%% THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+%% WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+%% MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+%% ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+%% WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+%% ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+%% OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+%% @doc Query processing functions.
+-module(glc_lib).
+
+-export([
+ reduce/1,
+ matches/2,
+ onoutput/1,
+ onoutput/2
+]).
+
+-ifdef(TEST).
+-include_lib("eunit/include/eunit.hrl").
+-undef(LET).
+-ifdef(PROPER).
+-include_lib("proper/include/proper.hrl").
+-endif.
+-endif.
+
+%% @doc Return a reduced version of a query.
+%% 
+%% The purpose of this function is to ensure that a query filter
+%% is in the simplest possible form. The query filter returned
+%% from this function is functionally equivalent to the original.
+reduce(Query) ->
+ repeat(Query, fun(Q0) ->
+ Q1 = repeat(Q0, fun flatten/1),
+ Q2 = required(Q1),
+ Q3 = repeat(Q2, fun flatten/1),
+ Q4 = common(Q3),
+ Q5 = repeat(Q4, fun flatten/1),
+ Q6 = constants(Q5),
+ Q6
+ end).
+
+
+%% @doc Test if an event matches a query.
+%% This function is only intended to be used for testing purposes.
+matches({any, Conds}, Event) ->
+ lists:any(fun(Cond) -> matches(Cond, Event) end, Conds);
+matches({all, Conds}, Event) ->
+ lists:all(fun(Cond) -> matches(Cond, Event) end, Conds);
+matches({null, Const}, _Event) ->
+ Const;
+matches({Key, '<', Term}, Event) ->
+ case gre:find(Key, Event) of
+ {true, Term2} -> Term2 < Term;
+ false -> false
+ end;
+matches({Key, '=<', Term}, Event) ->
+ case gre:find(Key, Event) of
+ {true, Term2} -> Term2 =< Term;
+ false -> false
+ end;
+matches({Key, '=', Term}, Event) ->
+ case gre:find(Key, Event) of
+ {true, Term2} -> Term2 =:= Term;
+ false -> false
+ end;
+matches({Key, '!=', Term}, Event) ->
+ case gre:find(Key, Event) of
+ {true, Term2} -> Term2 =/= Term;
+ false -> false
+ end;
+matches({Key, '>', Term}, Event) ->
+ case gre:find(Key, Event) of
+ {true, Term2} -> Term2 > Term;
+ false -> false
+ end;
+matches({Key, '>=', Term}, Event) ->
+ case gre:find(Key, Event) of
+ {true, Term2} -> Term2 >= Term;
+ false -> false
+ end;
+matches({Key, '*'}, Event) ->
+ case gre:find(Key, Event) of
+ {true, _} -> true;
+ false -> false
+ end;
+matches({Key, '!'}, Event) ->
+ not matches({Key, '*'}, Event).
+
+%% @private Repeatedly apply a function to a query.
+%% This is used for query transformation functions that must be applied
+%% multiple times to yield the simplest possible version of a query.
+repeat(Query, Fun) ->
+ case Fun(Query) of
+ Query -> Query;
+ Query2 -> repeat(Query2, Fun)
+ end.
+
+
+%% @doc Return the output action of a query.
+-spec onoutput(glc_ops:op()) -> output | no_return().
+onoutput({_, '<', _}) ->
+ output;
+onoutput({_, '=<', _}) ->
+ output;
+onoutput({_, '=', _}) ->
+ output;
+onoutput({_, '>', _}) ->
+ output;
+onoutput({_, '>=', _}) ->
+ output;
+onoutput({_, '*'}) ->
+ output;
+onoutput({_, '!'}) ->
+ output;
+onoutput(Query) ->
+ erlang:error(badarg, [Query]).
+
+%% @doc Modify the output action of a query.
+-spec onoutput(Action :: any(), Query :: glc_ops:op()) -> no_return().
+onoutput(Action, Query) ->
+ erlang:error(badarg, [Action, Query]).
+
+
+%% @private Flatten a condition tree.
+flatten({all, [Cond]}) ->
+ Cond;
+flatten({any, [Cond]}) ->
+ Cond;
+flatten({all, Conds}) ->
+ flatten_all([flatten(Cond) || Cond <- Conds]);
+flatten({any, [_|_]=Conds}) ->
+ flatten_any([flatten(Cond) || Cond <- Conds]);
+flatten({with, Cond, Action}) ->
+ {with, flatten(Cond), Action};
+flatten([{with, _Cond, _Action}|_] = I) ->
+ [{with, flatten(Cond), Action} || {with, Cond, Action} <- I];
+flatten(Other) ->
+ valid(Other).
+
+
+%% @private Flatten and remove duplicate members of an "all" filter.
+flatten_all(Conds) ->
+ {all, lists:usort(flatten_tag(all, Conds))}.
+
+%% @private Flatten and remove duplicate members of an "any" filter.
+flatten_any(Conds) ->
+ {any, lists:usort(flatten_tag(any, Conds))}.
+
+%% @private Common function for flattening "all" or "and" filters.
+flatten_tag(Tag, [{Tag, Conds}|T]) ->
+ Conds ++ flatten_tag(Tag, T);
+flatten_tag(Tag, [H|T]) ->
+ [H|flatten_tag(Tag, T)];
+flatten_tag(_Tag, []) ->
+ [].
+
+%% @private Factor out required filters.
+%%
+%% Identical conditions may occur in all sub-filters of an "any" filter. These
+%% filters can be tested once before testing the conditions that are unique to
+%% each sub-filter.
+%%
+%% Assume that the input has been flattened first in order to eliminate all
+%% occurances of an "any" filters being "sub-filters" of "any" filters.
+required({any, [H|_]=Conds}) ->
+ Init = ordsets:from_list(case H of {all, Init2} -> Init2; H -> [H] end),
+ case required(Conds, Init) of
+ nonefound ->
+ Conds2 = [required(Cond) || Cond <- Conds],
+ {any, Conds2};
+ {found, Req} ->
+ Conds2 = [required(deleteall(Cond, Req)) || Cond <- Conds],
+ {all, [{all, Req}, {any, Conds2}]}
+ end;
+required({all, Conds}) ->
+ {all, [required(Cond) || Cond <- Conds]};
+required(Other) ->
+ Other.
+
+required([{all, Conds}|T], Acc) ->
+ required(T, ordsets:intersection(ordsets:from_list(Conds), Acc));
+required([{any, _}|_]=Cond, Acc) ->
+ erlang:error(badarg, [Cond, Acc]);
+required([H|T], Acc) ->
+ required(T, ordsets:intersection(ordsets:from_list([H]), Acc));
+required([], [_|_]=Req) ->
+ {found, Req};
+required([], []) ->
+ nonefound.
+
+%% @private Factor our common filters.
+%%
+%% Identical conditions may occur in some sub-filters of an "all" filter. These
+%% filters can be tested once before testing the conditions that are unique to
+%% each sub-filter. This is different from factoring out common sub-filters
+%% in an "any" filter where the only those sub-filters that exist in all
+%% members.
+%%
+%% Assume that the input has been flattened first in order to eliminate all
+%% occurances of an "any" filters being "sub-filters" of "any" filters.
+common({all, Conds}) ->
+ case common_(Conds, []) of
+ {found, Found} ->
+ {all, [Found|[delete(Cond, Found) || Cond <- Conds]]};
+ nonefound ->
+ {all, [common(Cond) || Cond <- Conds]}
+ end;
+common({any, Conds}) ->
+ {any, [common(Cond) || Cond <- Conds]};
+common(Other) ->
+ Other.
+ 
+
+common_([{any, Conds}|T], Seen) ->
+ Set = ordsets:from_list(Conds),
+ case ordsets:intersection(Set, Seen) of
+ [] -> common_(T, ordsets:union(Set, Seen));
+ [H|_] -> {found, H}
+ end;
+common_([H|T], Seen) ->
+ case ordsets:is_element(H, Seen) of
+ false -> common_(T, ordsets:union(ordsets:from_list([H]), Seen));
+ true -> {found, H}
+ end;
+common_([], _Seen) ->
+ nonefound.
+
+%% @private Delete all occurances of constants.
+%%
+%% An "all" or "any" filter may be reduced to a constant outcome when all
+%% sub-filters has been factored out from the filter. In these cases the
+%% filter can be removed from the query.
+constants(Query) ->
+ delete(Query, {null, true}).
+ 
+
+
+%% @private Delete all occurances of a filter.
+%%
+%% Assume that the function is called because a filter is tested
+%% by a parent filter. It is therefore safe to replace occurances
+%% with a null filter that always returns true.
+delete({all, Conds}, Filter) ->
+ {all, [delete(Cond, Filter) || Cond <- Conds, Cond =/= Filter]};
+delete({any, Conds}, Filter) ->
+ {any, [delete(Cond, Filter) || Cond <- Conds, Cond =/= Filter]};
+delete(Filter, Filter) ->
+ {null, true};
+delete(Cond, _Filter) ->
+ Cond.
+
+%% @private Delete all occurances of multiple filters.
+deleteall(Filter, [H|T]) ->
+ deleteall(delete(Filter, H), T);
+deleteall(Filter, []) ->
+ Filter.
+
+
+
+%% @private Test if a term is a valid filter.
+-spec is_valid(glc_ops:op()) -> boolean().
+is_valid({Field, '<', _Term}) when is_atom(Field) ->
+ true;
+is_valid({Field, '=<', _Term}) when is_atom(Field) ->
+ true;
+is_valid({Field, '=', _Term}) when is_atom(Field) ->
+ true;
+is_valid({Field, '!=', _Term}) when is_atom(Field) ->
+ true;
+is_valid({Field, '>=', _Term}) when is_atom(Field) ->
+ true;
+is_valid({Field, '>', _Term}) when is_atom(Field) ->
+ true;
+is_valid({Field, '*'}) when is_atom(Field) ->
+ true;
+is_valid({Field, '!'}) when is_atom(Field) ->
+ true;
+is_valid({null, true}) ->
+ true;
+is_valid({null, false}) ->
+ true;
+is_valid(_Other) ->
+ false.
+
+%% @private Assert that a term is a valid filter.
+%% If the term is a valid filter. The original term will be returned.
+%% If the term is not a valid filter. A `badarg' error is thrown.
+valid(Term) ->
+ is_valid(Term) orelse erlang:error(badarg, [Term]),
+ Term.
+
+
+-ifdef(TEST).
+-include_lib("eunit/include/eunit.hrl").
+
+all_one_test() ->
+ ?assertEqual(glc:eq(a, 1),
+ glc_lib:reduce(glc:all([glc:eq(a, 1)]))
+ ).
+
+all_sort_test() ->
+ ?assertEqual(glc:all([glc:eq(a, 1), glc:eq(b, 2)]),
+ glc_lib:reduce(glc:all([glc:eq(b, 2), glc:eq(a, 1)]))
+ ).
+
+any_one_test() ->
+ ?assertEqual(glc:eq(a, 1),
+ glc_lib:reduce(glc:any([glc:eq(a, 1)]))
+ ).
+
+all_two_test() ->
+ ?assertEqual(glc_lib:reduce(glc:all([glc:wc(a), glc:nf(b)])),
+ glc_lib:reduce(glc:any([
+ glc:all([glc:wc(a)]), 
+ glc:all([glc:wc(a), glc:nf(b)])]))
+ ).
+
+any_sort_test() ->
+ ?assertEqual(glc:any([glc:eq(a, 1), glc:eq(b, 2)]),
+ glc_lib:reduce(glc:any([glc:eq(b, 2), glc:eq(a, 1)]))
+ ).
+
+all_nest_test() ->
+ ?assertEqual(glc:all([glc:eq(a, 1), glc:eq(b, 2)]),
+ glc_lib:reduce(glc:all([glc:eq(a, 1), glc:all([glc:eq(b, 2)])]))
+ ),
+ ?assertEqual(glc:all([glc:eq(a, 1), glc:eq(b, 2), glc:eq(c, 3)]),
+ glc_lib:reduce(glc:all([glc:eq(c, 3),
+ glc:all([glc:eq(a, 1),
+ glc:all([glc:eq(b, 2)])])]))
+ ).
+
+any_nest_test() ->
+ ?assertEqual(glc:any([glc:eq(a, 1), glc:eq(b, 2)]),
+ glc_lib:reduce(glc:any([glc:eq(a, 1), glc:any([glc:eq(b, 2)])]))
+ ),
+ ?assertEqual(glc:any([glc:eq(a, 1), glc:eq(b, 2), glc:eq(c, 3)]),
+ glc_lib:reduce(glc:any([glc:eq(c, 3),
+ glc:any([glc:eq(a, 1),
+ glc:any([glc:eq(b, 2)])])]))
+ ).
+
+all_equiv_test() ->
+ ?assertEqual(glc:eq(a, 1),
+ glc_lib:reduce(glc:all([glc:eq(a, 1), glc:eq(a, 1)]))
+ ).
+
+any_equiv_test() ->
+ ?assertEqual(glc:eq(a, 1),
+ glc_lib:reduce(glc:any([glc:eq(a, 1), glc:eq(a, 1)]))
+ ).
+
+any_required_test() ->
+ ?assertEqual(
+ glc:all([
+ glc:any([glc:nf(d), glc:eq(b, 2), glc:eq(c, 3)]),
+ glc:eq(a, 1)
+ ]),
+ glc_lib:reduce(
+ glc:any([
+ glc:all([glc:eq(a, 1), glc:nf(d)]),
+ glc:all([glc:eq(a, 1), glc:eq(b, 2)]),
+ glc:all([glc:eq(a, 1), glc:eq(c, 3)])]))
+ ).
+ 
+
+all_common_test() ->
+ ?assertEqual(
+ glc:all([glc:eq(a, 1), glc:eq(b, 2), glc:eq(c, 3)]),
+ glc_lib:reduce(
+ glc:all([
+ glc:any([glc:eq(a, 1), glc:eq(b, 2)]),
+ glc:any([glc:eq(a, 1), glc:eq(c, 3)])]))
+ ).
+
+delete_from_all_test() ->
+ ?assertEqual(
+ glc:all([glc:eq(b,2)]),
+ deleteall(
+ glc:all([glc:eq(a, 1),glc:eq(b,2)]), [glc:eq(a, 1), glc:nf(a)])
+ ).
+
+delete_from_any_test() ->
+ ?assertEqual(
+ glc:any([glc:eq(b,2)]),
+ deleteall(
+ glc:any([glc:eq(a, 1),glc:eq(b,2)]), [glc:eq(a, 1), glc:wc(a)])
+ ).
+
+default_is_output_test_() ->
+ [?_assertEqual(output, glc_lib:onoutput(glc:lt(a, 1))),
+ ?_assertEqual(output, glc_lib:onoutput(glc:lte(a, 1))),
+ ?_assertEqual(output, glc_lib:onoutput(glc:eq(a, 1))),
+ ?_assertEqual(output, glc_lib:onoutput(glc:gt(a, 1))),
+ ?_assertEqual(output, glc_lib:onoutput(glc:gte(a, 1))),
+ ?_assertEqual(output, glc_lib:onoutput(glc:wc(a))),
+ ?_assertEqual(output, glc_lib:onoutput(glc:nf(a)))
+ ].
+
+matches_test_() ->
+ Event = gre:make([{a, 2}], [list]),
+ [?_assertEqual(true, glc_lib:matches(glc:lt(a, 3), Event)),
+ ?_assertEqual(true, glc_lib:matches(glc:lte(a, 2), Event)),
+ ?_assertEqual(true, glc_lib:matches(glc:eq(a, 2), Event)),
+ ?_assertEqual(true, glc_lib:matches(glc:gt(a, 1), Event)),
+ ?_assertEqual(true, glc_lib:matches(glc:gte(a, 2), Event)),
+ ?_assertEqual(true, glc_lib:matches(glc:wc(a), Event)),
+ ?_assertEqual(true, glc_lib:matches(glc:nf(b), Event)),
+
+ ?_assertEqual(false, glc_lib:matches(glc:lt(a, 2), Event)),
+ ?_assertEqual(false, glc_lib:matches(glc:lte(a, 1), Event)),
+ ?_assertEqual(false, glc_lib:matches(glc:eq(a, 3), Event)),
+ ?_assertEqual(false, glc_lib:matches(glc:gt(a, 2), Event)),
+ ?_assertEqual(false, glc_lib:matches(glc:gte(a, 3), Event)),
+ ?_assertEqual(false, glc_lib:matches(glc:wc(b), Event)),
+ ?_assertEqual(false, glc_lib:matches(glc:nf(a), Event))
+ ].
+
+-ifdef(PROPER).
+
+
+prop_reduce_returns() ->
+ ?FORALL(Query, glc_ops:op(),
+ returns(fun() -> glc_lib:reduce(Query) end)).
+
+reduce_returns_test() ->
+ ?assert(proper:quickcheck(prop_reduce_returns())).
+
+prop_matches_returns_boolean() ->
+ ?FORALL({Query, Event}, {glc_ops:op(), [{atom(), term()}]},
+ is_boolean(glc_lib:matches(Query, gre:make(Event, [list])))).
+
+matches_returns_boolean_test() ->
+ ?assert(proper:quickcheck(prop_matches_returns_boolean())).
+
+returns(Fun) ->
+ try Fun(),
+ true
+ catch _:_ ->
+ false
+ end.
+
+-endif.
+-endif.

guam-0.9.11.tar.gz/_checkouts/goldrush/src/glc_ops.erl Added

@@ -0,0 +1,155 @@
+%% @doc Built in operators.
+-module(glc_ops).
+
+-export([
+ lt/2, lte/2,
+ eq/2, neq/2,
+ gt/2, gte/2,
+ wc/1,
+ nf/1
+]).
+
+-export([
+ all/1,
+ any/1,
+ null/1,
+ with/2
+]).
+
+-export([
+ union/1
+]).
+
+-type op() ::
+ {atom(), '<', term()} |
+ {atom(), '=<', term()} |
+ {atom(), '=', term()} |
+ {atom(), '!=', term()} |
+ {atom(), '>', term()} |
+ {atom(), '>=', term()} |
+ {atom(), '*'} |
+ {atom(), '!'} |
+ {any, [op(), ...]} |
+ {all, [op(), ...]} |
+ {null, true|false}.
+
+-export_type([op/0]).
+
+%% @doc Test that a field value is less than a term.
+-spec lt(atom(), term()) -> op().
+lt(Key, Term) when is_atom(Key) ->
+ {Key, '<', Term};
+lt(Key, Term) ->
+ erlang:error(badarg, [Key, Term]).
+
+
+%% @doc Test that a field value is less than or equal to a term.
+-spec lte(atom(), term()) -> op().
+lte(Key, Term) when is_atom(Key) ->
+ {Key, '=<', Term};
+lte(Key, Term) ->
+ erlang:error(badarg, [Key, Term]).
+
+%% @doc Test that a field value is equal to a term.
+-spec eq(atom(), term()) -> op().
+eq(Key, Term) when is_atom(Key) ->
+ {Key, '=', Term};
+eq(Key, Term) ->
+ erlang:error(badarg, [Key, Term]).
+
+%% @doc Test that a field value is not equal to a term.
+-spec neq(atom(), term()) -> op().
+neq(Key, Term) when is_atom(Key) ->
+ {Key, '!=', Term};
+neq(Key, Term) ->
+ erlang:error(badarg, [Key, Term]).
+
+
+%% @doc Test that a field value is greater than a term.
+-spec gt(atom(), term()) -> op().
+gt(Key, Term) when is_atom(Key) ->
+ {Key, '>', Term};
+gt(Key, Term) ->
+ erlang:error(badarg, [Key, Term]).
+
+%% @doc Test that a field value is greater than or equal to a term.
+-spec gte(atom(), term()) -> op().
+gte(Key, Term) when is_atom(Key) ->
+ {Key, '>=', Term};
+gte(Key, Term) ->
+ erlang:error(badarg, [Key, Term]).
+
+%% @doc Test that a field exists.
+-spec wc(atom()) -> op().
+wc(Key) when is_atom(Key) ->
+ {Key, '*'};
+wc(Key) ->
+ erlang:error(badarg, [Key]).
+
+%% @doc Test that a field is not found.
+-spec nf(atom()) -> op().
+nf(Key) when is_atom(Key) ->
+ {Key, '!'};
+nf(Key) ->
+ erlang:error(badarg, [Key]).
+
+%% @doc Filter the input using multiple filters.
+%%
+%% For an input to be considered valid output the all filters specified
+%% in the list must hold for the input event. The list is expected to
+%% be a non-empty list. If the list of filters is an empty list a `badarg'
+%% error will be thrown.
+-spec all([op()]) -> op().
+all([_|_]=Conds) ->
+ {all, Conds};
+all(Other) ->
+ erlang:error(badarg, [Other]).
+
+%% @doc Filter the input using one of multiple filters.
+%%
+%% For an input to be considered valid output on of the filters specified
+%% in the list must hold for the input event. The list is expected to be
+%% a non-empty list. If the list of filters is an empty list a `badarg'
+%% error will be thrown.
+-spec any([op()]) -> op().
+any([_|_]=Conds) ->
+ {any, Conds};
+any(Other) ->
+ erlang:error(badarg, [Other]).
+
+
+%% @doc Always return `true' or `false'.
+-spec null(boolean()) -> op().
+null(Result) when is_boolean(Result) ->
+ {null, Result};
+null(Result) ->
+ erlang:error(badarg, [Result]).
+
+%% @doc Apply a function to each output of a query.
+%%
+%% Updating the output action of a query finalizes it. Attempting
+%% to use a finalized query to construct a new query will result
+%% in a `badarg' error.
+-spec with(op(), fun((gre:event()) -> term())) -> op().
+with(Query, Fun) when is_function(Fun, 1);
+ is_function(Fun, 2) ->
+ {with, Query, Fun};
+with(Query, Fun) ->
+ erlang:error(badarg, [Query, Fun]).
+
+%% @doc Return a union of multiple queries.
+%%
+%% The union of multiple queries is the equivalent of executing multiple
+%% queries separately on the same input event. The advantage is that filter
+%% conditions that are common to all or some of the queries only need to
+%% be tested once.
+%%
+%% All queries are expected to be valid and have an output action other
+%% than the default which is `output'. If these expectations don't hold
+%% a `badarg' error will be thrown.
+-spec union([op()]) -> op().
+union(Queries) ->
+ case [Query || Query <- Queries, glc_lib:onoutput(Query) =:= output] of
+ [] -> {union, Queries};
+ [_|_] -> erlang:error(badarg, [Queries])
+ end.

guam-0.9.11.tar.gz/_checkouts/goldrush/src/glc_run.erl Added

guam-0.9.11.tar.gz/_checkouts/goldrush/src/goldrush.app.src Added

guam-0.9.11.tar.gz/_checkouts/goldrush/src/gr_app.erl Added

guam-0.9.11.tar.gz/_checkouts/goldrush/src/gr_context.erl Added

@@ -0,0 +1,71 @@
+%% Copyright (c) 2012, Magnus Klaar <klaar@ninenines.eu>
+%%
+%% Permission to use, copy, modify, and/or distribute this software for any
+%% purpose with or without fee is hereby granted, provided that the above
+%% copyright notice and this permission notice appear in all copies.
+%%
+%% THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+%% WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+%% MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+%% ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+%% WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+%% ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+%% OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+%% @doc Runtime context for events.
+-module(gr_context).
+
+-export([
+ make/1
+]).
+
+make(Options) ->
+ make_(undefined, undefined, undefined, undefined, Options).
+
+make_(_Node, App, Pid, Time, [{'$n', Node}|T]) ->
+ make_(Node, App, Pid, Time, T);
+make_(Node, _App, Pid, Time, [{'$a', App}|T]) ->
+ make_(Node, App, Pid, Time, T);
+make_(Node, App, _Pid, Time, [{'$p', Pid}|T]) ->
+ make_(Node, App, Pid, Time, T);
+make_(Node, App, Pid, _Time, [{'$t', Time}|T]) ->
+ make_(Node, App, Pid, Time, T);
+make_(Node, App, Pid, Time, []) ->
+ Pid2 = case Pid of undefined -> self(); _ -> Pid end,
+ Node2 = case Node of undefined -> node(Pid2); _ -> Node end,
+ App2 = case App of undefined -> application(Pid2); _ -> App end,
+ Time2 = case Time of undefined -> os:timestamp(); _ -> Time end,
+ {Node2, App2, Pid2, Time2}.
+
+application(Pid) when Pid =:= self() ->
+ case application:get_application(group_leader()) of
+ {ok, App} -> App;
+ undefined -> undefined
+ end;
+application(Pid) ->
+ {_, GroupLeader} = erlang:process_info(Pid, group_leader),
+ case application:get_application(GroupLeader) of
+ {ok, App} -> App;
+ undefined -> undefined
+ end.
+
+-ifdef(TEST).
+-include_lib("eunit/include/eunit.hrl").
+
+make_defaults_test() ->
+ {Node, App, Pid, Time} = gr_context:make([]),
+ ?assertEqual(Node, node()),
+ ?assertEqual(Pid, self()),
+ ?assert(is_atom(App)),
+ ?assertMatch({_,_,_}, Time).
+
+
+make_override_test() ->
+ Pid = spawn(fun() -> ok end),
+ {Node, App, Pid, Time} = gr_context:make([
+ {'$n', nodename}, {'$a', appname}, {'$p', Pid}, {'$t', timeval}]),
+ ?assertEqual(nodename, Node),
+ ?assertEqual(appname, App),
+ ?assertEqual(timeval, Time).
+
+-endif.

guam-0.9.11.tar.gz/_checkouts/goldrush/src/gr_counter.erl Added

@@ -0,0 +1,268 @@
+%% Copyright (c) 2013, Pedram Nimreezi <deadzen@deadzen.com>
+%%
+%% Permission to use, copy, modify, and/or distribute this software for any
+%% purpose with or without fee is hereby granted, provided that the above
+%% copyright notice and this permission notice appear in all copies.
+%%
+%% THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+%% WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+%% MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+%% ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+%% WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+%% ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+%% OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+-module(gr_counter).
+
+-behaviour(gen_server).
+
+%% API
+-export([start_link/1, 
+ list/1, lookup_element/2,
+ insert_counter/3,
+ update_counter/3, reset_counters/2]).
+
+%% gen_server callbacks
+-export([init/1,
+ handle_call/3,
+ handle_cast/2,
+ handle_info/2,
+ terminate/2,
+ code_change/3]).
+
+-record(state, {table_id, waiting=[]}).
+
+%%%===================================================================
+%%% API
+%%%===================================================================
+list(Server) ->
+ case (catch gen_server:call(Server, list)) of
+ {'EXIT', _Reason} ->
+ list(gr_manager:wait_for_pid(Server));
+ Else -> Else
+ end.
+
+lookup_element(Server, Term) ->
+ case (catch gen_server:call(Server, {lookup_element, Term})) of
+ {'EXIT', _Reason} ->
+ lookup_element(gr_manager:wait_for_pid(Server), Term);
+ Else -> Else
+ end.
+
+insert_counter(Server, Counter, Value) when is_atom(Server) ->
+ case whereis(Server) of
+ undefined -> 
+ insert_counter(gr_manager:wait_for_pid(Server), Counter, Value);
+ Pid -> 
+ case erlang:is_process_alive(Pid) of
+ true ->
+ insert_counter(Pid, Counter, Value);
+ false ->
+ ServerPid = gr_manager:wait_for_pid(Server),
+ insert_counter(ServerPid, Counter, Value)
+ end
+ end;
+insert_counter(Server, Counter, Value) when is_pid(Server) ->
+ case (catch gen_server:call(Server, {insert_counter, Counter, Value})) of
+ {'EXIT', _Reason} ->
+ insert_counter(gr_manager:wait_for_pid(Server), Counter, Value);
+ Else -> Else
+ end.
+
+update_counter(Server, Counter, Value) when is_atom(Server) ->
+ case whereis(Server) of
+ undefined -> 
+ update_counter(gr_manager:wait_for_pid(Server), Counter, Value);
+ Pid -> 
+ case erlang:is_process_alive(Pid) of
+ true ->
+ update_counter(Pid, Counter, Value);
+ false ->
+ ServerPid = gr_manager:wait_for_pid(Server),
+ update_counter(ServerPid, Counter, Value)
+ end
+ end;
+update_counter(Server, Counter, Value) when is_pid(Server) ->
+ gen_server:cast(Server, {update, Counter, Value}).
+
+reset_counters(Server, Counter) ->
+ case (catch gen_server:call(Server, {reset_counters, Counter})) of
+ {'EXIT', _Reason} ->
+ reset_counters(gr_manager:wait_for_pid(Server), Counter);
+ Else -> Else
+ end.
+
+%%--------------------------------------------------------------------
+%% @doc
+%% Starts the server
+%%
+%% @spec start_link(Name) -> {ok, Pid} | ignore | {error, Error}
+%% @end
+%%--------------------------------------------------------------------
+start_link(Name) ->
+ gen_server:start_link({local, Name}, ?MODULE, [], []).
+
+%%%===================================================================
+%%% gen_server callbacks
+%%%===================================================================
+
+%%--------------------------------------------------------------------
+%% @private
+%% @doc
+%% Initializes the server
+%%
+%% @spec init(Args) -> {ok, State} |
+%% {ok, State, Timeout} |
+%% ignore |
+%% {stop, Reason}
+%% @end
+%%--------------------------------------------------------------------
+init([]) ->
+ {ok, #state{}}.
+
+%%--------------------------------------------------------------------
+%% @private
+%% @doc
+%% Handling call messages
+%%
+%% @spec handle_call(Request, From, State) ->
+%% {reply, Reply, State} |
+%% {reply, Reply, State, Timeout} |
+%% {noreply, State} |
+%% {noreply, State, Timeout} |
+%% {stop, Reason, Reply, State} |
+%% {stop, Reason, State}
+%% @end
+%%--------------------------------------------------------------------
+handle_call(list=Call, From, State) ->
+ TableId = State#state.table_id,
+ Waiting = State#state.waiting,
+ case TableId of
+ undefined -> {noreply, State#state{waiting=[{Call, From}|Waiting]}};
+ _ -> {reply, lists:sort(handle_list(TableId)), State}
+ end;
+handle_call({lookup_element, Term}=Call, From, State) ->
+ TableId = State#state.table_id,
+ Waiting = State#state.waiting,
+ case TableId of
+ undefined -> {noreply, State#state{waiting=[{Call, From}|Waiting]}};
+ _ -> {reply, handle_lookup_element(TableId, Term), State}
+ end;
+handle_call({insert_counter, Counter, Value}, From, State) ->
+ Term = [{Counter, Value}],
+ Call = {insert, Term},
+ TableId = State#state.table_id,
+ Waiting = State#state.waiting,
+ case TableId of
+ undefined -> {noreply, State#state{waiting=[{Call, From}|Waiting]}};
+ _ -> {reply, handle_insert(TableId, Term), State}
+ end;
+handle_call({reset_counters, Counter}, From, State) ->
+ Term = case Counter of
+ _ when is_list(Counter) -> 
+ [{Item, 0} || Item <- Counter];
+ _ when is_atom(Counter) -> 
+ [{Counter, 0}]
+ end,
+ Call = {insert, Term},
+ TableId = State#state.table_id,
+ Waiting = State#state.waiting,
+ case TableId of
+ undefined -> {noreply, State#state{waiting=[{Call, From}|Waiting]}};
+ _ -> {reply, handle_insert(TableId, Term), State}
+ end;
+handle_call(_Request, _From, State) ->
+ Reply = {error, unhandled_message},
+ {reply, Reply, State}.
+
+%%--------------------------------------------------------------------
+%% @private
+%% @doc
+%% Handling cast messages
+%%
+%% @spec handle_cast(Msg, State) -> {noreply, State} |
+%% {noreply, State, Timeout} |
+%% {stop, Reason, State}
+%% @end
+%%--------------------------------------------------------------------
+handle_cast({update, Counter, Value}=Call, State) ->
+ TableId = State#state.table_id,
+ Waiting = State#state.waiting,
+ State2 = case TableId of
+ undefined -> State#state{waiting=[Call|Waiting]};
+ _ -> _ = handle_update_counter(TableId, Counter, Value), 
+ State
+ end,
+ {noreply, State2};
+handle_cast(_Msg, State) ->
+ {noreply, State}.
+
+%%--------------------------------------------------------------------
+%% @private
+%% @doc
+%% Handling all non call/cast messages
+%%
+%% @spec handle_info(Info, State) -> {noreply, State} |
+%% {noreply, State, Timeout} |
+%% {stop, Reason, State}
+%% @end
+%%--------------------------------------------------------------------
+handle_info({'ETS-TRANSFER', TableId, _Pid, _Data}, State) ->
+ _ = [ gen_server:reply(From, perform_call(TableId, Call)) 
+ || {Call, From} <- State#state.waiting ],
+ _ = [ handle_update_counter(TableId, Counter, Value) 
+ || {update, Counter, Value} <- State#state.waiting ],
+ {noreply, State#state{table_id=TableId, waiting=[]}};
+handle_info(_Info, State) ->
+ {noreply, State}.
+
+%%--------------------------------------------------------------------
+%% @private
+%% @doc
+%% This function is called by a gen_server when it is about to
+%% terminate. It should be the opposite of Module:init/1 and do any
+%% necessary cleaning up. When it returns, the gen_server terminates
+%% with Reason. The return value is ignored.
+%%
+%% @spec terminate(Reason, State) -> void()
+%% @end
+%%--------------------------------------------------------------------
+terminate(_Reason, _State) ->
+ ok.
+
+%%--------------------------------------------------------------------
+%% @private
+%% @doc
+%% Convert process state when code is changed
+%%
+%% @spec code_change(OldVsn, State, Extra) -> {ok, NewState}
+%% @end
+%%--------------------------------------------------------------------
+code_change(_OldVsn, State, _Extra) ->
+ {ok, State}.
+
+%%%===================================================================
+%%% Internal functions
+%%%===================================================================
+
+perform_call(TableId, Call) ->
+ case Call of
+ list ->
+ handle_list(TableId);
+ {insert, Term} ->
+ handle_insert(TableId, Term);
+ {lookup_element, Term} ->
+ handle_lookup_element(TableId, Term)
+ end.
+
+handle_list(TableId) ->
+ ets:tab2list(TableId).
+
+handle_update_counter(TableId, Counter, Value) ->
+ ets:update_counter(TableId, Counter, Value).
+
+handle_insert(TableId, Term) ->
+ ets:insert(TableId, Term).
+
+handle_lookup_element(TableId, Term) ->
+ ets:lookup_element(TableId, Term, 2).

guam-0.9.11.tar.gz/_checkouts/goldrush/src/gr_counter_sup.erl Added

@@ -0,0 +1,42 @@
+%% Copyright (c) 2013, Pedram Nimreezi <deadzen@deadzen.com>
+%%
+%% Permission to use, copy, modify, and/or distribute this software for any
+%% purpose with or without fee is hereby granted, provided that the above
+%% copyright notice and this permission notice appear in all copies.
+%%
+%% THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+%% WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+%% MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+%% ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+%% WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+%% ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+%% OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+-module(gr_counter_sup).
+
+-behaviour(supervisor).
+
+-type startlink_err() :: {'already_started', pid()} | 'shutdown' | term().
+-type startlink_ret() :: {'ok', pid()} | 'ignore' | {'error', startlink_err()}.
+
+%% API
+-export([start_link/0]).
+
+%% Supervisor callbacks
+-export([init/1]).
+
+%% ===================================================================
+%% API functions
+%% ===================================================================
+%% @hidden
+-spec start_link() -> startlink_ret().
+start_link() ->
+ supervisor:start_link({local, ?MODULE}, ?MODULE, []).
+
+%% ===================================================================
+%% Supervisor callbacks
+%% ===================================================================
+%% @hidden
+-spec init([]) -> {ok, { {one_for_one, 50, 10}, [supervisor:child_spec()]} }.
+init(_Args) ->
+ {ok, { {one_for_one, 50, 10}, []} }.

guam-0.9.11.tar.gz/_checkouts/goldrush/src/gr_manager.erl Added

@@ -0,0 +1,185 @@
+%% Copyright (c) 2013, Pedram Nimreezi <deadzen@deadzen.com>
+%%
+%% Permission to use, copy, modify, and/or distribute this software for any
+%% purpose with or without fee is hereby granted, provided that the above
+%% copyright notice and this permission notice appear in all copies.
+%%
+%% THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+%% WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+%% MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+%% ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+%% WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+%% ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+%% OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+
+%% @doc Process table manager for goldrush.
+%%
+%% Manager responsible for the processes, which serve as heir of the 
+%% {@link gr_counter:start_link/0. Counter} and
+%% {@link gr_param:start_link/0. Param} ets table processes.
+%% This process creates the table and initial data then assigns itself
+%% to inherit the ets table if any process responsible for it is killed.
+%% It then waits to give it back while that process is recreated by its 
+%% supervisor.
+-module(gr_manager).
+-behaviour(gen_server).
+
+%% API
+-export([start_link/3, wait_for_pid/1]).
+
+%% gen_server callbacks
+-export([init/1,
+ handle_call/3,
+ handle_cast/2,
+ handle_info/2,
+ terminate/2,
+ code_change/3]).
+
+-define(SERVER, ?MODULE).
+
+-record(state, {table_id :: ets:tab(), managee :: atom()}).
+
+%%%===================================================================
+%%% API
+%%%===================================================================
+
+%% Setup the initial data for the ets table
+-spec setup(atom() | pid(), term()) -> ok.
+setup(Name, Data) ->
+ gen_server:cast(Name, {setup, Data}).
+
+%%--------------------------------------------------------------------
+%% @doc
+%% Starts the server
+%%
+%% @spec start_link(Name, Managee, Data) -> {ok, Pid} | ignore | 
+%% {error, Error}
+%% @end
+%%--------------------------------------------------------------------
+start_link(Name, Managee, Data) ->
+ gen_server:start_link({local, Name}, ?MODULE, [Managee, Data], []).
+
+%%%===================================================================
+%%% gen_server callbacks
+%%%===================================================================
+
+%%--------------------------------------------------------------------
+%% @private
+%% @doc
+%% Initializes the server
+%%
+%% @spec init(Args) -> {ok, State} |
+%% {ok, State, Timeout} |
+%% ignore |
+%% {stop, Reason}
+%% @end
+%%--------------------------------------------------------------------
+init([Managee, Data]) ->
+ process_flag(trap_exit, true),
+ setup(self(), Data),
+ {ok, #state{managee=Managee}}.
+
+%%--------------------------------------------------------------------
+%% @private
+%% @doc
+%% Handling call messages
+%%
+%% @spec handle_call(Request, From, State) ->
+%% {reply, Reply, State} |
+%% {reply, Reply, State, Timeout} |
+%% {noreply, State} |
+%% {noreply, State, Timeout} |
+%% {stop, Reason, Reply, State} |
+%% {stop, Reason, State}
+%% @end
+%%--------------------------------------------------------------------
+handle_call(_Request, _From, State) ->
+ Reply = {error, unhandled_message},
+ {reply, Reply, State}.
+
+%%--------------------------------------------------------------------
+%% @private
+%% @doc
+%% Handling cast messages
+%%
+%% @spec handle_cast(Msg, State) -> {noreply, State} |
+%% {noreply, State, Timeout} |
+%% {stop, Reason, State}
+%% @end
+%%--------------------------------------------------------------------
+handle_cast({setup, Data}, State = #state{managee=Managee}) ->
+ ManageePid = whereis(Managee),
+ link(ManageePid),
+ TableId = ets:new(?MODULE, [set, private]),
+ ets:insert(TableId, Data),
+ ets:setopts(TableId, {heir, self(), Data}),
+ ets:give_away(TableId, ManageePid, Data),
+ {noreply, State#state{table_id=TableId}};
+handle_cast(_Msg, State) ->
+ {noreply, State}.
+
+%%--------------------------------------------------------------------
+%% @private
+%% @doc
+%% Handling all non call/cast messages
+%%
+%% @spec handle_info(Info, State) -> {noreply, State} |
+%% {noreply, State, Timeout} |
+%% {stop, Reason, State}
+%% @end
+%%--------------------------------------------------------------------
+handle_info({'EXIT', _Pid, _Reason}, State) ->
+ {noreply, State};
+handle_info({'ETS-TRANSFER', TableId, _Pid, Data}, State = #state{managee=Managee}) ->
+ ManageePid = wait_for_pid(Managee),
+ link(ManageePid),
+ ets:give_away(TableId, ManageePid, Data),
+ {noreply, State#state{table_id=TableId}}.
+
+%% @doc Wait for a registered process to be associated to a process identifier.
+%% @spec wait_for_pid(Managee) -> ManageePid
+-spec wait_for_pid(atom()) -> pid().
+wait_for_pid(Managee) when is_pid(Managee) -> 
+ Managee;
+wait_for_pid(Managee) when is_atom(Managee), Managee =/= undefined -> 
+ case whereis(Managee) of
+ undefined -> 
+ timer:sleep(1),
+ wait_for_pid(Managee);
+ ManageePid -> ManageePid
+ end.
+
+
+
+%%--------------------------------------------------------------------
+%% @private
+%% @doc
+%% This function is called by a gen_server when it is about to
+%% terminate. It should be the opposite of Module:init/1 and do any
+%% necessary cleaning up. When it returns, the gen_server terminates
+%% with Reason. The return value is ignored.
+%%
+%% @spec terminate(Reason, State) -> void()
+%% @end
+%%--------------------------------------------------------------------
+terminate(_Reason, _State) ->
+ ok.
+
+%%--------------------------------------------------------------------
+%% @private
+%% @doc
+%% Convert process state when code is changed
+%%
+%% @spec code_change(OldVsn, State, Extra) -> {ok, NewState}
+%% @end
+%%--------------------------------------------------------------------
+code_change(_OldVsn, State, _Extra) ->
+ {ok, State}.
+
+%%%===================================================================
+%%% Internal functions
+%%%===================================================================
+
+
+

guam-0.9.11.tar.gz/_checkouts/goldrush/src/gr_manager_sup.erl Added

@@ -0,0 +1,47 @@
+%% Copyright (c) 2013, Pedram Nimreezi <deadzen@deadzen.com>
+%%
+%% Permission to use, copy, modify, and/or distribute this software for any
+%% purpose with or without fee is hereby granted, provided that the above
+%% copyright notice and this permission notice appear in all copies.
+%%
+%% THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+%% WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+%% MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+%% ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+%% WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+%% ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+%% OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+%% @doc Table manager supervisor for all goldrush ets process tables.
+%%
+%% Manager supervisor responsible for the {@link gr_manager:start_link/3. 
+%% Manager} processes, which serve as heir of the 
+%% {@link gr_counter:start_link/0. Counter} and
+%% {@link gr_param:start_link/0. Param} ets table processes.
+-module(gr_manager_sup).
+-behaviour(supervisor).
+
+-type startlink_err() :: {'already_started', pid()} | 'shutdown' | term().
+-type startlink_ret() :: {'ok', pid()} | 'ignore' | {'error', startlink_err()}.
+
+%% API
+-export([start_link/0]).
+
+%% Supervisor callbacks
+-export([init/1]).
+
+%% ===================================================================
+%% API functions
+%% ===================================================================
+%% @hidden
+-spec start_link() -> startlink_ret().
+start_link() ->
+ supervisor:start_link({local, ?MODULE}, ?MODULE, []).
+
+%% ===================================================================
+%% Supervisor callbacks
+%% ===================================================================
+%% @hidden
+-spec init([]) -> {ok, { {one_for_one, 50, 10}, [supervisor:child_spec()]} }.
+init(_Args) ->
+ {ok, { {one_for_one, 50, 10}, []} }.

guam-0.9.11.tar.gz/_checkouts/goldrush/src/gr_param.erl Added

@@ -0,0 +1,269 @@
+%% Copyright (c) 2013, Pedram Nimreezi <deadzen@deadzen.com>
+%%
+%% Permission to use, copy, modify, and/or distribute this software for any
+%% purpose with or without fee is hereby granted, provided that the above
+%% copyright notice and this permission notice appear in all copies.
+%%
+%% THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+%% WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+%% MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+%% ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+%% WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+%% ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+%% OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+-module(gr_param).
+
+-behaviour(gen_server).
+
+%% API
+-export([start_link/1, 
+ list/1, insert/2, 
+ lookup/2, lookup_element/2,
+ info/1, info_size/1, transform/1]).
+
+%% gen_server callbacks
+-export([init/1,
+ handle_call/3,
+ handle_cast/2,
+ handle_info/2,
+ terminate/2,
+ code_change/3]).
+
+-record(state, {table_id, waiting=[]}).
+
+%%%===================================================================
+%%% API
+%%%===================================================================
+list(Server) ->
+ case (catch gen_server:call(Server, list)) of
+ {'EXIT', _Reason} ->
+ list(gr_manager:wait_for_pid(Server));
+ Else -> Else
+ end.
+
+info_size(Server) ->
+ case (catch gen_server:call(Server, info_size)) of
+ {'EXIT', _Reason} ->
+ info_size(gr_manager:wait_for_pid(Server));
+ Else -> Else
+ end.
+
+insert(Server, Term) ->
+ case (catch gen_server:call(Server, {insert, Term})) of
+ {'EXIT', _Reason} ->
+ insert(gr_manager:wait_for_pid(Server), Term);
+ Else -> Else
+ end.
+
+lookup(Server, Term) ->
+ case (catch gen_server:call(Server, {lookup, Term})) of
+ {'EXIT', _Reason} ->
+ lookup(gr_manager:wait_for_pid(Server), Term);
+ Else -> Else
+ end.
+
+lookup_element(Server, Term) ->
+ case (catch gen_server:call(Server, {lookup_element, Term})) of
+ {'EXIT', _Reason} ->
+ lookup_element(gr_manager:wait_for_pid(Server), Term);
+ Else -> Else
+ end.
+
+info(Server) ->
+ case (catch gen_server:call(Server, info)) of
+ {'EXIT', _Reason} ->
+ info(gr_manager:wait_for_pid(Server));
+ Else -> Else
+ end.
+
+%% @doc Transform Term -> Key to Key -> Term
+transform(Server) ->
+ case (catch gen_server:call(Server, transform)) of
+ {'EXIT', _Reason} ->
+ transform(gr_manager:wait_for_pid(Server));
+ Else -> Else
+ end.
+
+%%--------------------------------------------------------------------
+%% @doc
+%% Starts the server
+%%
+%% @spec start_link(Name) -> {ok, Pid} | ignore | {error, Error}
+%% @end
+%%--------------------------------------------------------------------
+start_link(Name) ->
+ gen_server:start_link({local, Name}, ?MODULE, [], []).
+
+%%%===================================================================
+%%% gen_server callbacks
+%%%===================================================================
+
+%%--------------------------------------------------------------------
+%% @private
+%% @doc
+%% Initializes the server
+%%
+%% @spec init(Args) -> {ok, State} |
+%% {ok, State, Timeout} |
+%% ignore |
+%% {stop, Reason}
+%% @end
+%%--------------------------------------------------------------------
+init([]) ->
+ {ok, #state{}}.
+
+%%--------------------------------------------------------------------
+%% @private
+%% @doc
+%% Handling call messages
+%%
+%% @spec handle_call(Request, From, State) ->
+%% {reply, Reply, State} |
+%% {reply, Reply, State, Timeout} |
+%% {noreply, State} |
+%% {noreply, State, Timeout} |
+%% {stop, Reason, Reply, State} |
+%% {stop, Reason, State}
+%% @end
+%%--------------------------------------------------------------------
+handle_call(Call, From, State) when is_atom(Call), Call =:= list; 
+ Call =:= info; Call =:= info_size;
+ Call =:= transform ->
+ TableId = State#state.table_id,
+ Waiting = State#state.waiting,
+ case TableId of
+ undefined -> {noreply, State#state{waiting=[{Call, From}|Waiting]}};
+ _ when Call =:= list -> 
+ {reply, handle_list(TableId), State};
+ _ when Call =:= info -> 
+ {reply, handle_info(TableId), State};
+ _ when Call =:= info_size -> 
+ {reply, handle_info_size(TableId), State};
+ _ when Call =:= transform -> 
+ {reply, handle_transform(TableId), State}
+ end;
+
+handle_call({Call, Term}, From, State) when is_atom(Call), Call =:= insert; 
+ Call =:= lookup; 
+ Call =:= lookup_element ->
+ TableId = State#state.table_id,
+ Waiting = State#state.waiting,
+ case TableId of
+ undefined -> 
+ {noreply, State#state{waiting=[{{Call, Term}, From}|Waiting]}};
+ _ when Call =:= insert -> 
+ {reply, handle_insert(TableId, Term), State};
+ _ when Call =:= lookup -> 
+ {reply, handle_lookup(TableId, Term), State};
+ _ when Call =:= lookup_element -> 
+ {reply, handle_lookup_element(TableId, Term), State}
+ end;
+
+handle_call(_Request, _From, State) ->
+ Reply = {error, unhandled_message},
+ {reply, Reply, State}.
+
+%%--------------------------------------------------------------------
+%% @private
+%% @doc
+%% Handling cast messages
+%%
+%% @spec handle_cast(Msg, State) -> {noreply, State} |
+%% {noreply, State, Timeout} |
+%% {stop, Reason, State}
+%% @end
+%%--------------------------------------------------------------------
+handle_cast(_Msg, State) ->
+ {noreply, State}.
+
+%%--------------------------------------------------------------------
+%% @private
+%% @doc
+%% Handling all non call/cast messages
+%%
+%% @spec handle_info(Info, State) -> {noreply, State} |
+%% {noreply, State, Timeout} |
+%% {stop, Reason, State}
+%% @end
+%%--------------------------------------------------------------------
+handle_info({'ETS-TRANSFER', TableId, _Pid, _Data}, State) ->
+ _ = [ gen_server:reply(From, perform_call(TableId, Call)) 
+ || {Call, From} <- State#state.waiting ],
+ {noreply, State#state{table_id=TableId, waiting=[]}};
+handle_info(_Info, State) ->
+ {noreply, State}.
+
+
+
+%%--------------------------------------------------------------------
+%% @private
+%% @doc
+%% This function is called by a gen_server when it is about to
+%% terminate. It should be the opposite of Module:init/1 and do any
+%% necessary cleaning up. When it returns, the gen_server terminates
+%% with Reason. The return value is ignored.
+%%
+%% @spec terminate(Reason, State) -> void()
+%% @end
+%%--------------------------------------------------------------------
+terminate(_Reason, _State) ->
+ ok.
+
+%%--------------------------------------------------------------------
+%% @private
+%% @doc
+%% Convert process state when code is changed
+%%
+%% @spec code_change(OldVsn, State, Extra) -> {ok, NewState}
+%% @end
+%%--------------------------------------------------------------------
+code_change(_OldVsn, State, _Extra) ->
+ {ok, State}.
+
+%%%===================================================================
+%%% Internal functions
+%%%===================================================================
+
+perform_call(TableId, Call) ->
+ case Call of
+ list ->
+ handle_list(TableId);
+ info ->
+ handle_info(TableId);
+ info_size ->
+ handle_info_size(TableId);
+ transform ->
+ handle_transform(TableId);
+ {insert, Term} ->
+ handle_insert(TableId, Term);
+ {lookup, Term} ->
+ handle_lookup(TableId, Term);
+ {lookup_element, Term} ->
+ handle_lookup_element(TableId, Term)
+ end.
+
+
+handle_list(TableId) ->
+ ets:tab2list(TableId).
+
+handle_info(TableId) ->
+ ets:info(TableId).
+
+handle_info_size(TableId) ->
+ ets:info(TableId, size).
+
+handle_transform(TableId) ->
+ ParamsList = [{K, V} || {V, K} <- ets:tab2list(TableId)],
+ ets:delete_all_objects(TableId),
+ ets:insert(TableId, ParamsList).
+
+handle_insert(TableId, Term) ->
+ ets:insert(TableId, Term).
+
+handle_lookup(TableId, Term) ->
+ ets:lookup(TableId, Term).
+
+handle_lookup_element(TableId, Term) ->
+ ets:lookup_element(TableId, Term, 2).
+

guam-0.9.11.tar.gz/_checkouts/goldrush/src/gr_param_sup.erl Added

@@ -0,0 +1,48 @@
+%% Copyright (c) 2013, Pedram Nimreezi <deadzen@deadzen.com>
+%%
+%% Permission to use, copy, modify, and/or distribute this software for any
+%% purpose with or without fee is hereby granted, provided that the above
+%% copyright notice and this permission notice appear in all copies.
+%%
+%% THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+%% WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+%% MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+%% ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+%% WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+%% ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+%% OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+%% @doc Second level supervisor for goldrush.
+%%
+%% Supervisor for the {@link gr_param:start_link/0. 
+%% Param}, process table responsible for params
+%% {@link gr_param:start_link/0. Counter} and
+%% their {@link gr_counter:start_link/0. Manager} supervisors.
+
+-module(gr_param_sup).
+-behaviour(supervisor).
+
+-type startlink_err() :: {'already_started', pid()} | 'shutdown' | term().
+-type startlink_ret() :: {'ok', pid()} | 'ignore' | {'error', startlink_err()}.
+
+%% API
+-export([start_link/0]).
+
+%% Supervisor callbacks
+-export([init/1]).
+
+%% ===================================================================
+%% API functions
+%% ===================================================================
+%% @hidden
+-spec start_link() -> startlink_ret().
+start_link() ->
+ supervisor:start_link({local, ?MODULE}, ?MODULE, []).
+
+%% ===================================================================
+%% Supervisor callbacks
+%% ===================================================================
+%% @hidden
+-spec init([]) -> {ok, { {one_for_one, 50, 10}, [supervisor:child_spec()]} }.
+init(_Args) ->
+ {ok, { {one_for_one, 50, 10}, []} }.

guam-0.9.11.tar.gz/_checkouts/goldrush/src/gr_sup.erl Added

@@ -0,0 +1,42 @@
+%% Copyright (c) 2012, Magnus Klaar <klaar@ninenines.eu>
+%% Copyright (c) 2013, Pedram Nimreezi <deadzen@deadzen.com>
+%%
+%% Permission to use, copy, modify, and/or distribute this software for any
+%% purpose with or without fee is hereby granted, provided that the above
+%% copyright notice and this permission notice appear in all copies.
+%%
+%% THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+%% WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+%% MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+%% ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+%% WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+%% ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+%% OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+
+%% @doc Top level supervisor for goldrush.
+%%
+%% Main supervisor responsible for the {@link gr_counter_sup:start_link/0. 
+%% Counter}, {@link gr_param_sup:start_link/0. Param} and
+%% their {@link gr_manager_sup:start_link/0. Manager} supervisors.
+-module(gr_sup).
+-behaviour(supervisor).
+
+-type startlink_err() :: {'already_started', pid()} | 'shutdown' | term().
+-type startlink_ret() :: {'ok', pid()} | 'ignore' | {'error', startlink_err()}.
+
+-export([start_link/0]).
+-export([init/1]).
+
+-define(CHILD(I, Type), {I, {I, start_link, []}, permanent, 5000, Type, [I]}).
+
+-spec start_link() -> startlink_ret().
+start_link() ->
+ supervisor:start_link({local, ?MODULE}, ?MODULE, []).
+
+-spec init([]) -> {ok, { {one_for_one, 50, 10}, [supervisor:child_spec()]} }.
+init([]) ->
+ CounterSup = ?CHILD(gr_counter_sup, supervisor),
+ ParamSup = ?CHILD(gr_param_sup, supervisor),
+ MgrSup = ?CHILD(gr_manager_sup, supervisor),
+ {ok, {{one_for_one, 50, 10}, [CounterSup, ParamSup, MgrSup]}}.

guam-0.9.11.tar.gz/_checkouts/goldrush/src/gre.erl Added

@@ -0,0 +1,104 @@
+%% Copyright (c) 2012, Magnus Klaar <klaar@ninenines.eu>
+%%
+%% Permission to use, copy, modify, and/or distribute this software for any
+%% purpose with or without fee is hereby granted, provided that the above
+%% copyright notice and this permission notice appear in all copies.
+%%
+%% THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+%% WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+%% MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+%% ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+%% WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+%% ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+%% OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+%% @doc Accessor function for goldrush event terms.
+-module(gre).
+
+-export([
+ make/2,
+ has/2,
+ fetch/2,
+ append/2,
+ merge/2,
+ find/2,
+ keys/1,
+ pairs/1
+]).
+
+-type event() :: {list, [{atom(), term()}]}.
+-export_type([event/0]).
+
+%% @doc Construct an event term.
+-spec make(term(), [list]) -> event().
+make(Term, [Type]) ->
+ {Type, Term}.
+
+
+%% @doc Check if a field exists in an event.
+-spec has(atom(), event()) -> boolean().
+has(Key, {list, List}) ->
+ lists:keymember(Key, 1, List).
+
+-spec append(term(), event()) -> event().
+append(KeyVal, {list, List}) ->
+ {list, [KeyVal|List]}.
+
+-spec merge(event(), event()) -> event().
+merge({list, AList}, {list, BList}) ->
+ {list, lists:merge(AList, BList)}.
+
+%% @doc Get the value of a field in an event.
+%% The field is expected to exist in the event.
+-spec fetch(atom(), event()) -> term().
+fetch(Key, {list, List}=Event) ->
+ case lists:keyfind(Key, 1, List) of
+ {_, Value} -> Value;
+ false -> erlang:error(badarg, [Key, Event])
+ end.
+
+
+%% @doc Find the value of a field in an event.
+%% This is equivalent to testing if a field exists using {@link has/2}
+%% before accessing the value of the field using {@link fetch/2}.
+-spec find(atom(), event()) -> {true, term()} | false.
+find(Key, {list, List}) ->
+ case lists:keyfind(Key, 1, List) of
+ {_, Value} -> {true, Value};
+ false -> false
+ end.
+
+
+%% @doc Get the names of all fields in an event.
+-spec keys(event()) -> [atom()].
+keys({list, List}) ->
+ kv_keys_(List).
+
+%% @private Get the names of all fields in a key-value list.
+-spec kv_keys_([{atom(), term()}]) -> [atom()].
+kv_keys_([{Key, _}|T]) ->
+ [Key|kv_keys_(T)];
+kv_keys_([]) ->
+ [].
+
+%% @doc Get the name and value of all fields in an event.
+-spec pairs(event()) -> [{atom(), term()}].
+pairs({list, List}) ->
+ lists:sort(List).
+
+
+-ifdef(TEST).
+-include_lib("eunit/include/eunit.hrl").
+
+gre_test_() ->
+ [?_assert(gre:has(a, gre:make([{a,1}], [list]))),
+ ?_assertNot(gre:has(b, gre:make([{a,1}], [list]))),
+ ?_assertEqual(1, gre:fetch(a, gre:make([{a,1}], [list]))),
+ ?_assertError(badarg, gre:fetch(a, gre:make([], [list]))),
+ ?_assertEqual([], gre:keys(gre:make([], [list]))),
+ ?_assertEqual([a], gre:keys(gre:make([{a,1}], [list]))),
+ ?_assertEqual([a,b], gre:keys(gre:make([{a,1},{b,2}], [list]))),
+ ?_assertEqual([{a,1},{b,2}], gre:pairs(gre:make([{b,2},{a,1}], [list])))
+ ].
+
+-endif.

guam-0.9.11.tar.gz/_checkouts/lager Added

guam-0.9.11.tar.gz/_checkouts/lager/LICENSE Added

@@ -0,0 +1,178 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+

guam-0.9.11.tar.gz/_checkouts/lager/README.md Added

@@ -0,0 +1,1400 @@
+Overview
+--------
+Lager (as in the beer) is a logging framework for Erlang. Its purpose is
+to provide a more traditional way to perform logging in an erlang application
+that plays nicely with traditional UNIX logging tools like logrotate and
+syslog.
+
+[![Build Status](https://github.com/erlang-lager/lager/workflows/build/badge.svg)](https://github.com/erlang-lager/lager)
+[![Hex pm](https://img.shields.io/hexpm/v/lager)](https://hex.pm/packages/lager)
+
+Features
+--------
+* Finer grained log levels (debug, info, notice, warning, error, critical,
+ alert, emergency)
+* Logger calls are transformed using a parse transform to allow capturing
+ Module/Function/Line/Pid information
+* When no handler is consuming a log level (eg. debug) no event is sent
+ to the log handler
+* Supports multiple backends, including console and file.
+* Supports multiple sinks
+* Rewrites common OTP error messages into more readable messages
+* Support for pretty printing records encountered at compile time
+* Tolerant in the face of large or many log messages, won't out of memory the node
+* Optional feature to bypass log size truncation ("unsafe")
+* Supports internal time and date based rotation, as well as external rotation tools
+* Syslog style log level comparison flags
+* Colored terminal output (requires R16+)
+* Map support (requires 17+)
+* Optional load shedding by setting a high water mark to kill (and reinstall)
+ a sink after a configurable cool down timer
+
+Contributing
+------------
+We welcome contributions from the community. We are always excited to get ideas
+for improving lager.
+
+If you are looking for an idea to help out, please take a look at our open
+issues - a number of them are tagged with [Help Wanted](https://github.com/erlang-lager/lager/issues?q=is%3Aopen+is%3Aissue+label%3A%22Help+Wanted%22)
+and [Easy](https://github.com/erlang-lager/lager/issues?q=is%3Aopen+is%3Aissue+label%3AEasy) - some
+of them are tagged as both! We are happy to mentor people get started with any
+of these issues, and they don't need prior discussion.
+
+That being said, before you send large changes please open an issue first to
+discuss the change you'd like to make along with an idea of your proposal to
+implement that change.
+
+### PR guidelines ###
+
+* Large changes without prior discussion are likely to be rejected.
+* Changes without test cases are likely to be rejected.
+* Please use the style of the existing codebase when submitting PRs.
+
+We review PRs and issues at least once a month as described below.
+
+OTP Support Policy
+------------------
+The lager maintainers intend to support the past three OTP releases from
+current on the main 3.x branch of the project. As of August 2019 that includes
+22, 21 20
+
+Lager may or may not run on older OTP releases but it will only be guaranteed
+tested on the previous three OTP releases. If you need a version of lager
+which runs on older OTP releases, we recommend you use either the 3.4.0 release
+or the 2.x branch.
+
+Monthly triage cadence
+----------------------
+We have (at least) monthly issue and PR triage for lager in the #lager room on the
+[freenode](https://freenode.net) IRC network every third Thursday at 2 pm US/Pacific,
+10 pm UTC. You are welcome to join us there to ask questions about lager or
+participate in the triage.
+
+Usage
+-----
+To use lager in your application, you need to define it as a rebar dep or have
+some other way of including it in Erlang's path. You can then add the
+following option to the erlang compiler flags:
+
+```erlang
+{parse_transform, lager_transform}
+```
+
+Alternately, you can add it to the module you wish to compile with logging
+enabled:
+
+```erlang
+-compile([{parse_transform, lager_transform}]).
+```
+
+Before logging any messages, you'll need to start the lager application. The
+lager module's `start` function takes care of loading and starting any dependencies
+lager requires.
+
+```erlang
+lager:start().
+```
+
+You can also start lager on startup with a switch to `erl`:
+
+```erlang
+erl -pa path/to/lager/ebin -s lager
+```
+
+Once you have built your code with lager and started the lager application,
+you can then generate log messages by doing the following:
+
+```erlang
+lager:error("Some message")
+```
+
+ Or:
+
+```erlang
+lager:warning("Some message with a term: ~p", [Term])
+```
+
+The general form is `lager:Severity()` where `Severity` is one of the log levels
+mentioned above.
+
+Configuration
+-------------
+To configure lager's backends, you use an application variable (probably in
+your app.config):
+
+```erlang
+{lager, [
+ {log_root, "/var/log/hello"},
+ {handlers, [
+ {lager_console_backend, [{level, info}]},
+ {lager_file_backend, [{file, "error.log"}, {level, error}]},
+ {lager_file_backend, [{file, "console.log"}, {level, info}]}
+ ]}
+]}.
+```
+
+```log_root``` variable is optional, by default file paths are relative to CWD.
+
+The available configuration options for each backend are listed in their
+module's documentation.
+
+Sinks
+-----
+Lager has traditionally supported a single sink (implemented as a
+`gen_event` manager) named `lager_event` to which all backends were
+connected.
+
+Lager now supports extra sinks; each sink can have different
+sync/async message thresholds and different backends.
+
+### Sink configuration
+
+To use multiple sinks (beyond the built-in sink of lager and lager_event), you
+need to:
+
+1. Setup rebar.config
+2. Configure the backends in app.config
+
+#### Names
+
+Each sink has two names: one atom to be used like a module name for
+sending messages, and that atom with `_lager_event` appended for backend
+configuration.
+
+This reflects the legacy behavior: `lager:info` (or `critical`, or
+`debug`, etc) is a way of sending a message to a sink named
+`lager_event`. Now developers can invoke `audit:info` or
+`myCompanyName:debug` so long as the corresponding `audit_lager_event` or
+`myCompanyName_lager_event` sinks are configured.
+
+#### rebar.config
+
+In `rebar.config` for the project that requires lager, include a list
+of sink names (without the `_lager_event` suffix) in `erl_opts`:
+
+`{lager_extra_sinks, [audit]}`
+
+#### Runtime requirements
+
+To be useful, sinks must be configured at runtime with backends.
+
+In `app.config` for the project that requires lager, for example,
+extend the lager configuration to include an `extra_sinks` tuple with
+backends (aka "handlers") and optionally `async_threshold` and
+`async_threshold_window` values (see **Overload Protection**
+below). If async values are not configured, no overload protection
+will be applied on that sink.
+
+```erlang
+[{lager, [
+ {log_root, "/tmp"},
+
+ %% Default handlers for lager/lager_event
+ {handlers, [
+ {lager_console_backend, [{level, info}]},
+ {lager_file_backend, [{file, "error.log"}, {level, error}]},
+ {lager_file_backend, [{file, "console.log"}, {level, info}]}
+ ]},
+
+ %% Any other sinks
+ {extra_sinks,
+ [
+ {audit_lager_event,
+ [{handlers,
+ [{lager_file_backend,
+ [{file, "sink1.log"},
+ {level, info}
+ ]
+ }]
+ },
+ {async_threshold, 500},
+ {async_threshold_window, 50}]
+ }]
+ }
+ ]
+ }
+].
+```
+
+Custom Formatting
+-----------------
+All loggers have a default formatting that can be overriden. A formatter is any module that
+exports `format(#lager_log_message{},Config#any())`. It is specified as part of the configuration
+for the backend:
+
+```erlang
+{lager, [
+ {handlers, [
+ {lager_console_backend, [{level, info}, {formatter, lager_default_formatter},
+ {formatter_config, [time," [",severity,"] ", message, "\n"]}]},
+ {lager_file_backend, [{file, "error.log"}, {level, error}, {formatter, lager_default_formatter},
+ {formatter_config, [date, " ", time," [",severity,"] ",pid, " ", message, "\n"]}]},
+ {lager_file_backend, [{file, "console.log"}, {level, info}]}
+ ]}
+]}.
+```
+
+Included is `lager_default_formatter`. This provides a generic, default
+formatting for log messages using a structure similar to Erlang's
+[iolist](http://learnyousomeerlang.com/buckets-of-sockets#io-lists) which we
+call "semi-iolist":
+
+* Any traditional iolist elements in the configuration are printed verbatim.
+* Atoms in the configuration are treated as placeholders for lager metadata and
+ extracted from the log message.
+ * The placeholders `date`, `time`, `message`, `sev` and `severity` will always exist.
+ * `sev` is an abbreviated severity which is interpreted as a capitalized
+ single letter encoding of the severity level (e.g. `'debug'` -> `$D`)
+ * The placeholders `pid`, `file`, `line`, `module`, `function`, and `node`
+ will always exist if the parse transform is used.
+ * The placeholder `application` may exist if the parse transform is used.
+ It is dependent on finding the applications `app.src` file.
+ * If the error logger integration is used, the placeholder `pid`
+ will always exist and the placeholder `name` may exist.
+ * Applications can define their own metadata placeholder.
+ * A tuple of `{atom(), semi-iolist()}` allows for a fallback for
+ the atom placeholder. If the value represented by the atom
+ cannot be found, the semi-iolist will be interpreted instead.
+ * A tuple of `{atom(), semi-iolist(), semi-iolist()}` represents a
+ conditional operator: if a value for the atom placeholder can be
+ found, the first semi-iolist will be output; otherwise, the
+ second will be used.
+ * A tuple of `{pterm, atom()}` will attempt to lookup
+ the value of the specified atom from the
+ [persistent_term](http://erlang.org/doc/man/persistent_term.html)
+ feature added in OTP 21.2. The default value is `""`. The
+ default value will be used if the key cannot be found or
+ if this formatting term is specified on an OTP release before
+ OTP 21.
+ * A tuple of `{pterm, atom(), semi-iolist()}` will attempt to
+ lookup the value of the specified atom from the persistent_term
+ feature added in OTP 21.2. The default value is the specified
+ semi-iolist(). The default value will be used if the key cannot
+ be found or the if this formatting term is specified on an OTP
+ release before OTP 21.
+
+Examples:
+
+```
+["Foo"] -> "Foo", regardless of message content.
+[message] -> The content of the logged message, alone.
+[{pid,"Unknown Pid"}] -> "<?.?.?>" if pid is in the metadata, "Unknown Pid" if not.
+[{pid, ["My pid is ", pid], ["Unknown Pid"]}] -> if pid is in the metadata print "My pid is <?.?.?>", otherwise print "Unknown Pid"
+[{server,{pid, ["(", pid, ")"], ["(Unknown Server)"]}}] -> user provided server metadata, otherwise "(<?.?.?>)", otherwise "(Unknown Server)"
+[{pterm, pterm_key, <<"undefined">>}] -> if a value for 'pterm_key' is found in OTP 21 (or later) persistent_term storage it is used, otherwise "undefined"
+```
+
+Universal time
+--------------
+By default, lager formats timestamps as local time for whatever computer
+generated the log message.
+
+To make lager use UTC timestamps, you can set the `sasl` application's
+`utc_log` configuration parameter to `true` in your application configuration
+file.
+
+Example:
+
+```
+%% format log timestamps as UTC
+[{sasl, [{utc_log, true}]}].
+```
+
+Error logger integration
+------------------------
+Lager is also supplied with a `error_logger` handler module that translates
+traditional erlang error messages into a friendlier format and sends them into
+lager itself to be treated like a regular lager log call. To disable this, set
+the lager application variable `error_logger_redirect` to `false`.
+You can also disable reformatting for OTP and Cowboy messages by setting variable
+`error_logger_format_raw` to `true`.
+
+If you installed your own handler(s) into `error_logger`, you can tell
+lager to leave it alone by using the `error_logger_whitelist` environment
+variable with a list of handlers to allow.
+
+```
+{error_logger_whitelist, [my_handler]}
+```
+
+The `error_logger` handler will also log more complete error messages (protected
+with use of `trunc_io`) to a "crash log" which can be referred to for further
+information. The location of the crash log can be specified by the `crash_log`
+application variable. If set to `false` it is not written at all.
+
+Messages in the crash log are subject to a maximum message size which can be
+specified via the `crash_log_msg_size` application variable.
+
+Messages from `error_logger` will be redirected to `error_logger_lager_event` sink
+if it is defined so it can be redirected to another log file.
+
+For example:
+
+```
+[{lager, [
+ {extra_sinks,
+ [
+ {error_logger_lager_event, 
+ [{handlers, [
+ {lager_file_backend, [{file, "error_logger.log"}, {level, info}]}]
+ }]
+ }]
+ }]
+}].
+```
+will send all `error_logger` messages to `error_logger.log` file.
+
+Overload Protection
+-------------------
+
+### Asynchronous mode
+
+Prior to lager 2.0, the `gen_event` at the core of lager operated purely in
+synchronous mode. Asynchronous mode is faster, but has no protection against
+message queue overload. As of lager 2.0, the `gen_event` takes a hybrid
+approach. it polls its own mailbox size and toggles the messaging between
+synchronous and asynchronous depending on mailbox size.
+
+```erlang
+{async_threshold, 20},
+{async_threshold_window, 5}
+```
+
+This will use async messaging until the mailbox exceeds 20 messages, at which
+point synchronous messaging will be used, and switch back to asynchronous, when
+size reduces to `20 - 5 = 15`.
+
+If you wish to disable this behaviour, simply set `async_threshold` to `undefined`. It defaults
+to a low number to prevent the mailbox growing rapidly beyond the limit and causing
+problems. In general, lager should process messages as fast as they come in, so getting
+20 behind should be relatively exceptional anyway.
+
+If you want to limit the number of messages per second allowed from `error_logger`,
+which is a good idea if you want to weather a flood of messages when lots of
+related processes crash, you can set a limit:
+
+```erlang
+{error_logger_hwm, 50}
+```
+
+It is probably best to keep this number small.
+
+### Event queue flushing
+
+When the high-water mark is exceeded, lager can be configured to flush all
+event notifications in the message queue. This can have unintended consequences
+for other handlers in the same event manager (in e.g. the `error_logger`), as
+events they rely on may be wrongly discarded. By default, this behavior is enabled,
+but can be controlled, for the `error_logger` via:
+
+```erlang
+{error_logger_flush_queue, true | false}
+```
+
+or for a specific sink, using the option:
+
+```erlang
+{flush_queue, true | false}
+```
+
+If `flush_queue` is true, a message queue length threshold can be set, at which
+messages will start being discarded. The default threshold is `0`, meaning that
+if `flush_queue` is true, messages will be discarded if the high-water mark is
+exceeded, regardless of the length of the message queue. The option to control
+the threshold is, for `error_logger`:
+
+```erlang
+{error_logger_flush_threshold, 1000}
+```
+
+and for sinks:
+
+```erlang
+{flush_threshold, 1000}
+```
+
+### Sink Killer
+
+In some high volume situations, it may be preferable to drop all pending log
+messages instead of letting them drain over time.
+
+If you prefer, you may choose to use the sink killer to shed load. In this
+operational mode, if the `gen_event` mailbox exceeds a configurable
+high water mark, the sink will be killed and reinstalled after a
+configurable cool down time.
+
+You can configure this behavior by using these configuration directives:
+
+```erlang
+{killer_hwm, 1000},
+{killer_reinstall_after, 5000}
+```
+
+This means if the sink's mailbox size exceeds 1000 messages, kill the
+entire sink and reload it after 5000 milliseconds. This behavior can
+also be installed into alternative sinks if desired.
+
+By default, the manager killer *is not installed* into any sink. If
+the `killer_reinstall_after` cool down time is not specified it defaults
+to 5000.
+
+"Unsafe"
+--------
+The unsafe code pathway bypasses the normal lager formatting code and uses the
+same code as error_logger in OTP. This provides a marginal speedup to your logging
+code (we measured between 0.5-1.3% improvement during our benchmarking; others have
+reported better improvements.)
+
+This is a **dangerous** feature. It *will not* protect you against
+large log messages - large messages can kill your application and even your
+Erlang VM dead due to memory exhaustion as large terms are copied over and
+over in a failure cascade. We strongly recommend that this code pathway
+only be used by log messages with a well bounded upper size of around 500 bytes.
+
+If there's any possibility the log messages could exceed that limit, you should
+use the normal lager message formatting code which will provide the appropriate
+size limitations and protection against memory exhaustion.
+
+If you want to format an unsafe log message, you may use the severity level (as
+usual) followed by `_unsafe`. Here's an example:
+
+```erlang
+lager:info_unsafe("The quick brown ~s jumped over the lazy ~s", ["fox", "dog"]).
+```
+
+Runtime loglevel changes
+------------------------
+You can change the log level of any lager backend at runtime by doing the
+following:
+
+```erlang
+lager:set_loglevel(lager_console_backend, debug).
+```
+
+ Or, for the backend with multiple handles (files, mainly):
+
+```erlang
+lager:set_loglevel(lager_file_backend, "console.log", debug).
+```
+
+Lager keeps track of the minimum log level being used by any backend and
+suppresses generation of messages lower than that level. This means that debug
+log messages, when no backend is consuming debug messages, are effectively
+free. A simple benchmark of doing 1 million debug log messages while the
+minimum threshold was above that takes less than half a second.
+
+Syslog style loglevel comparison flags
+--------------------------------------
+In addition to the regular log level names, you can also do finer grained masking
+of what you want to log:
+
+```
+info - info and higher (>= is implicit)
+=debug - only the debug level
+!=info - everything but the info level
+<=notice - notice and below
+<warning - anything less than warning
+```
+
+These can be used anywhere a loglevel is supplied, although they need to be either
+a quoted atom or a string.
+
+Internal log rotation
+---------------------
+Lager can rotate its own logs or have it done via an external process. To
+use internal rotation, use the `size`, `date` and `count` values in the file
+backend's config:
+
+```erlang
+[{file, "error.log"}, {level, error}, {size, 10485760}, {date, "$D0"}, {count, 5}]
+```
+
+This tells lager to log error and above messages to `error.log` and to
+rotate the file at midnight or when it reaches 10mb, whichever comes first,
+and to keep 5 rotated logs in addition to the current one. Setting the
+count to 0 does not disable rotation, it instead rotates the file and keeps
+no previous versions around. To disable rotation set the size to 0 and the
+date to "".
+
+The `$D0` syntax is taken from the syntax newsyslog uses in newsyslog.conf.
+The relevant extract follows:
+
+```
+Day, week and month time format: The lead-in character
+for day, week and month specification is a `$'-sign.
+The particular format of day, week and month
+specification is: [Dhh], [Ww[Dhh]] and [Mdd[Dhh]],
+respectively. Optional time fields default to
+midnight. The ranges for day and hour specifications
+are:
+
+ hh hours, range 0 ... 23
+ w day of week, range 0 ... 6, 0 = Sunday
+ dd day of month, range 1 ... 31, or the
+ letter L or l to specify the last day of
+ the month.
+
+Some examples:
+ $D0 rotate every night at midnight
+ $D23 rotate every day at 23:00 hr
+ $W0D23 rotate every week on Sunday at 23:00 hr
+ $W5D16 rotate every week on Friday at 16:00 hr
+ $M1D0 rotate on the first day of every month at
+ midnight (i.e., the start of the day)
+ $M5D6 rotate on every 5th day of the month at
+ 6:00 hr
+```
+
+On top of the day, week and month time format from newsyslog,
+hour specification is added from PR [#420](https://github.com/erlang-lager/lager/pull/420)
+
+```
+Format of hour specification is : [Hmm]
+The range for minute specification is:
+
+ mm minutes, range 0 ... 59
+
+Some examples:
+
+ $H00 rotate every hour at HH:00
+ $D12H30 rotate every day at 12:30
+ $W0D0H0 rotate every week on Sunday at 00:00
+```
+
+To configure the crash log rotation, the following application variables are
+used:
+* `crash_log_size`
+* `crash_log_date`
+* `crash_log_count`
+* `crash_log_rotator`
+
+See the `.app.src` file for further details.
+
+Custom Log Rotation
+-------------------
+Custom log rotator could be configured with option for `lager_file_backend`
+```erlang
+{rotator, lager_rotator_default}
+```
+
+The module should provide the following callbacks as `lager_rotator_behaviour`
+
+```erlang
+%% @doc Create a log file
+-callback(create_logfile(Name::list(), Buffer::{integer(), integer()} | any()) ->
+ {ok, {FD::file:io_device(), Inode::integer(), Size::integer()}} | {error, any()}).
+
+%% @doc Open a log file
+-callback(open_logfile(Name::list(), Buffer::{integer(), integer()} | any()) ->
+ {ok, {FD::file:io_device(), Inode::integer(), Size::integer()}} | {error, any()}).
+
+%% @doc Ensure reference to current target, could be rotated
+-callback(ensure_logfile(Name::list(), FD::file:io_device(), Inode::integer(),
+ Buffer::{integer(), integer()} | any()) ->
+ {ok, {FD::file:io_device(), Inode::integer(), Size::integer()}} | {error, any()}).
+
+%% @doc Rotate the log file
+-callback(rotate_logfile(Name::list(), Count::integer()) ->
+ ok).
+```
+
+Syslog Support
+--------------
+Lager syslog output is provided as a separate application:
+[lager_syslog](https://github.com/erlang-lager/lager_syslog). It is packaged as a
+separate application so lager itself doesn't have an indirect dependency on a
+port driver. Please see the `lager_syslog` README for configuration information.
+
+Other Backends
+--------------
+There are lots of them! Some connect log messages to AMQP, various logging
+analytic services ([bunyan](https://github.com/Vagabond/lager_bunyan_formatter),
+[loggly](https://github.com/kivra/lager_loggly), etc), and more. [Looking on
+hex](https://hex.pm/packages?_utf8=✓&search=lager&sort=recent_downloads) or
+using "lager BACKEND" where "BACKEND" is your preferred log solution
+on your favorite search engine is a good starting point.
+
+Exception Pretty Printing
+----------------------
+Up to OTP 20:
+
+```erlang
+try
+ foo()
+catch
+ Class:Reason ->
+ lager:error(
+ "~nStacktrace:~s",
+ [lager:pr_stacktrace(erlang:get_stacktrace(), {Class, Reason})])
+end.
+```
+
+On OTP 21+:
+
+```erlang
+try
+ foo()
+catch
+ Class:Reason:Stacktrace ->
+ lager:error(
+ "~nStacktrace:~s",
+ [lager:pr_stacktrace(Stacktrace, {Class, Reason})])
+end.
+```
+
+Record Pretty Printing
+----------------------
+Lager's parse transform will keep track of any record definitions it encounters
+and store them in the module's attributes. You can then, at runtime, print any
+record a module compiled with the lager parse transform knows about by using the
+`lager:pr/2` function, which takes the record and the module that knows about the record:
+
+```erlang
+lager:info("My state is ~p", [lager:pr(State, ?MODULE)])
+```
+
+Often, `?MODULE` is sufficent, but you can obviously substitute that for a literal module name.
+`lager:pr` also works from the shell.
+
+Colored terminal output
+-----------------------
+If you have Erlang R16 or higher, you can tell lager's console backend to be colored. Simply
+add to lager's application environment config:
+
+```erlang
+{colored, true}
+```
+
+If you don't like the default colors, they are also configurable; see
+the `.app.src` file for more details.
+
+The output will be colored from the first occurrence of the atom color
+in the formatting configuration. For example:
+
+```erlang
+{lager_console_backend, [{level, info}, {formatter, lager_default_formatter},
+ {formatter_config, [time, color, " [",severity,"] ", message, "\e[0m\r\n"]}]]}
+```
+
+This will make the entire log message, except time, colored. The
+escape sequence before the line break is needed in order to reset the
+color after each log message.
+
+Tracing
+-------
+Lager supports basic support for redirecting log messages based on log message
+attributes. Lager automatically captures the pid, module, function and line at the
+log message callsite. However, you can add any additional attributes you wish:
+
+```erlang
+lager:warning([{request, RequestID},{vhost, Vhost}], "Permission denied to ~s", [User])
+```
+
+Then, in addition to the default trace attributes, you'll be able to trace
+based on request or vhost:
+
+```erlang
+lager:trace_file("logs/example.com.error", [{vhost, "example.com"}], error)
+```
+
+To persist metadata for the life of a process, you can use `lager:md/1` to store metadata
+in the process dictionary:
+
+```erlang
+lager:md([{zone, forbidden}])
+```
+
+Note that `lager:md` will *only* accept a list of key/value pairs keyed by atoms.
+
+You can also omit the final argument, and the loglevel will default to
+`debug`.
+
+Tracing to the console is similar:
+
+```erlang
+lager:trace_console([{request, 117}])
+```
+
+In the above example, the loglevel is omitted, but it can be specified as the
+second argument if desired.
+
+You can also specify multiple expressions in a filter, or use the `*` atom as
+a wildcard to match any message that has that attribute, regardless of its
+value. You may also use the special value `!` to mean, only select if this
+key is **not** present.
+
+Tracing to an existing logfile is also supported (but see **Multiple
+sink support** below):
+
+```erlang
+lager:trace_file("log/error.log", [{module, mymodule}, {function, myfunction}], warning)
+```
+
+To view the active log backends and traces, you can use the `lager:status()`
+function. To clear all active traces, you can use `lager:clear_all_traces()`.
+
+To delete a specific trace, store a handle for the trace when you create it,
+that you later pass to `lager:stop_trace/1`:
+
+```erlang
+{ok, Trace} = lager:trace_file("log/error.log", [{module, mymodule}]),
+...
+lager:stop_trace(Trace)
+```
+
+Tracing to a pid is somewhat of a special case, since a pid is not a
+data-type that serializes well. To trace by pid, use the pid as a string:
+
+```erlang
+lager:trace_console([{pid, "<0.410.0>"}])
+```
+
+### Filter expressions
+As of lager 3.3.1, you can also use a 3 tuple while tracing where the second
+element is a comparison operator. The currently supported comparison operators
+are:
+
+* `<` - less than
+* `=<` - less than or equal
+* `=` - equal to
+* `!=` - not equal to
+* `>` - greater than
+* `>=` - greater than or equal
+
+```erlang
+lager:trace_console([{request, '>', 117}, {request, '<', 120}])
+```
+
+Using `=` is equivalent to the 2-tuple form.
+
+### Filter composition
+As of lager 3.3.1 you may also use the special filter composition keys of
+`all` or `any`. For example the filter example above could be
+expressed as:
+
+```erlang
+lager:trace_console([{all, [{request, '>', 117}, {request, '<', 120}]}])
+```
+
+`any` has the effect of "OR style" logical evaluation between filters; `all`
+means "AND style" logical evaluation between filters. These compositional filters
+expect a list of additional filter expressions as their values.
+
+### Null filters
+The `null` filter has a special meaning. A filter of `{null, false}` acts as
+a black hole; nothing is passed through. A filter of `{null, true}` means
+*everything* passes through. No other values for the null filter are valid and
+will be rejected.
+
+### Multiple sink support
+
+If using multiple sinks, there are limitations on tracing that you
+should be aware of.
+
+Traces are specific to a sink, which can be specified via trace
+filters:
+
+```erlang
+lager:trace_file("log/security.log", [{sink, audit_event}, {function, myfunction}], warning)
+```
+
+If no sink is thus specified, the default lager sink will be used.
+
+This has two ramifications:
+
+* Traces cannot intercept messages sent to a different sink.
+* Tracing to a file already opened via `lager:trace_file` will only be
+ successful if the same sink is specified.
+
+The former can be ameliorated by opening multiple traces; the latter
+can be fixed by rearchitecting lager's file backend, but this has not
+been tackled.
+
+### Traces from configuration
+
+Lager supports starting traces from its configuration file. The keyword
+to define them is `traces`, followed by a proplist of tuples that define
+a backend handler and zero or more filters in a required list,
+followed by an optional message severity level.
+
+An example looks like this:
+
+```erlang
+{lager, [
+ {handlers, [...]},
+ {traces, [
+ %% handler, filter, message level (defaults to debug if not given)
+ {lager_console_backend, [{module, foo}], info },
+ {{lager_file_backend, "trace.log"}, [{request, '>', 120}], error},
+ {{lager_file_backend, "event.log"}, [{module, bar}] } %% implied debug level here
+ ]}
+]}.
+```
+
+In this example, we have three traces. One using the console backend, and two
+using the file backend. If the message severity level is left out, it defaults
+to `debug` as in the last file backend example.
+
+The `traces` keyword works on alternative sinks too but the same limitations
+and caveats noted above apply.
+
+**IMPORTANT**: You **must** define a severity level in all lager releases
+up to and including 3.1.0 or previous. The 2-tuple form wasn't added until
+3.2.0.
+
+Setting dynamic metadata at compile-time
+----------------------------------------
+Lager supports supplying metadata from external sources by registering a 
+callback function. This metadata is also persistent across processes even if 
+the process dies.
+
+In general use you won't need to use this feature. However it is useful in 
+situations such as:
+ * Tracing information provided by 
+ [seq_trace](http://erlang.org/doc/man/seq_trace.html)
+ * Contextual information about your application
+ * Persistent information which isn't provided by the default placeholders
+ * Situations where you would have to set the metadata before every logging call 
+
+You can add the callbacks by using the `{lager_parse_transform_functions, X}` 
+option. It is only available when using `parse_transform`. In rebar, you can 
+add it to `erl_opts` as below:
+
+```erlang
+{erl_opts, [{parse_transform, lager_transform}, 
+ {lager_function_transforms, 
+ [
+ %% Placeholder Resolve type Callback tuple
+ {metadata_placeholder, on_emit, {module_name, function_name}},
+ {other_metadata_placeholder, on_log, {module_name, function_name}}
+ ]}]}.
+```
+
+The first atom is the placeholder atom used for the substitution in your custom
+ formatter. See [Custom Formatting](#custom-formatting) for more information.
+
+The second atom is the resolve type. This specify the callback to resolve at 
+the time of the message being emitted or at the time of the logging call. You 
+have to specify either the atom `on_emit` or `on_log`. There is not a 'right' 
+resolve type to use, so please read the uses/caveats of each and pick the option 
+which fits your requirements best.
+ 
+`on_emit`:
+ * The callback functions are not resolved until the message is emitted by the
+ backend.
+ * If the callback function cannot be resolved, not loaded or produces 
+ unhandled errors then `undefined` will be returned.
+ * Since the callback function is dependent on a process, there is the 
+ chance that message will be emitted after the dependent process has died 
+ resulting in `undefined` being returned. This process can also be your own
+ process
+ 
+`on_log`:
+ * The callback functions are resolved regardless whether the message is 
+ emitted or not
+ * If the callback function cannot be resolved or not loaded the errors are 
+ not handled by lager itself.
+ * Any potential errors in callback should be handled in the callback function
+ itself.
+ * Because the function is resolved at log time there should be less chance
+ of the dependent process dying before you can resolve it, especially if
+ you are logging from the app which contains the callback.
+
+The third element is the callback to your function consisting of a tuple in the
+form `{Module Function}`. The callback should look like the following 
+regardless if using `on_emit` or `on_log`: 
+ * It should be exported
+ * It should takes no arguments e.g. has an arity of 0
+ * It should return any traditional iolist elements or the atom `undefined`
+ * For errors generated within your callback see the resolve type documentation
+ above.
+
+If the callback returns `undefined` then it will follow the same fallback and
+conditional operator rules as documented in the 
+[Custom Formatting](#custom-formatting) section. 
+
+This example would work with `on_emit` but could be unsafe to use with 
+`on_log`. If the call failed in `on_emit` it would default to `undefined`, 
+however with `on_log` it would error.
+
+```erlang
+-export([my_callback/0]).
+
+my_callback() ->
+ my_app_serv:call('some options').
+```
+
+This example would be to safe to work with both `on_emit` and `on_log`
+
+```erlang
+-export([my_callback/0]).
+
+my_callback() ->
+ try my_app_serv:call('some options') of
+ Result ->
+ Result
+ catch
+ _ ->
+ %% You could define any traditional iolist elements you wanted here
+ undefined
+ end.
+```
+
+Note that the callback can be any Module:Function/0. It does not have be part 
+of your application. For example you could use `cpu_sup:avg1/0` as your 
+callback function like so `{cpu_avg1, on_emit, {cpu_sup, avg1}}`
+
+
+Examples:
+
+```erlang
+-export([reductions/0]).
+
+reductions() ->
+ proplists:get_value(reductions, erlang:process_info(self())).
+```
+
+```erlang
+-export([seq_trace/0]).
+
+seq_trace() ->
+ case seq_trace:get_token(label) of
+ {label, TraceLabel} ->
+ TraceLabel;
+ _ ->
+ undefined
+ end.
+```
+
+**IMPORTANT**: Since `on_emit` relies on function calls injected at the
+point where a log message is emitted, your logging performance (ops/sec)
+will be impacted by what the functions you call do and how much latency they
+may introduce. This impact will even greater with `on_log` since the calls
+are injected at the point a message is logged.
+
+Setting the truncation limit at compile-time
+--------------------------------------------
+Lager defaults to truncating messages at 4096 bytes, you can alter this by
+using the `{lager_truncation_size, X}` option. In rebar, you can add it to
+`erl_opts`:
+
+```erlang
+{erl_opts, [{parse_transform, lager_transform}, {lager_truncation_size, 1024}]}.
+```
+
+You can also pass it to `erlc`, if you prefer:
+
+```
+erlc -pa lager/ebin +'{parse_transform, lager_transform}' +'{lager_truncation_size, 1024}' file.erl
+```
+
+Suppress applications and supervisors start/stop logs
+-----------------------------------------------------
+If you don't want to see supervisors and applications start/stop logs in debug
+level of your application, you can use these configs to turn it off:
+
+```erlang
+{lager, [{suppress_application_start_stop, true},
+ {suppress_supervisor_start_stop, true}]}
+```
+
+Sys debug functions
+--------------------
+
+Lager provides an integrated way to use sys 'debug functions'. You can install a debug
+function in a target process by doing
+
+```erlang
+lager:install_trace(Pid, notice).
+```
+
+You can also customize the tracing somewhat:
+
+```erlang
+lager:install_trace(Pid, notice, [{count, 100}, {timeout, 5000}, {format_string, "my trace event ~p ~p"]}).
+```
+
+The trace options are currently:
+
+* timeout - how long the trace stays installed: `infinity` (the default) or a millisecond timeout
+* count - how many trace events to log: `infinity` (default) or a positive number
+* format_string - the format string to log the event with. *Must* have 2 format specifiers for the 2 parameters supplied.
+
+This will, on every 'system event' for an OTP process (usually inbound messages, replies
+and state changes) generate a lager message at the specified log level.
+
+You can remove the trace when you're done by doing:
+
+```erlang
+lager:remove_trace(Pid).
+```
+
+If you want to start an OTP process with tracing enabled from the very beginning, you can do something like this:
+
+```erlang
+gen_server:start_link(mymodule, [], [{debug, [{install, {fun lager:trace_func/3, lager:trace_state(undefined, notice, [])}}]}]).
+```
+
+The third argument to the trace_state function is the Option list documented above.
+
+Console output to another group leader process
+----------------------------------------------
+
+If you want to send your console output to another group_leader (typically on
+another node) you can provide a `{group_leader, Pid}` argument to the console
+backend. This can be combined with another console config option, `id` and
+gen_event's `{Module, ID}` to allow remote tracing of a node to standard out via
+nodetool:
+
+```erlang
+ GL = erlang:group_leader(),
+ Node = node(GL),
+ lager_app:start_handler(lager_event, {lager_console_backend, Node},
+ [{group_leader, GL}, {level, none}, {id, {lager_console_backend, Node}}]),
+ case lager:trace({lager_console_backend, Node}, Filter, Level) of
+ ...
+```
+
+In the above example, the code is assumed to be running via a `nodetool rpc`
+invocation so that the code is executing on the Erlang node, but the
+group_leader is that of the reltool node (eg. appname_maint_12345@127.0.0.1).
+
+If you intend to use tracing with this feature, make sure the second parameter
+to start_handler and the `id` parameter match. Thus when the custom group_leader
+process exits, lager will remove any associated traces for that handler.
+
+Elixir Support
+--------------
+
+There are 2 ways in which Lager can be leveraged in an Elixir project:
+
+1. Lager Backend for Elixir Logger
+2. Directly
+
+### Lager Backend for Elixir Logger
+
+[Elixir's Logger](https://hexdocs.pm/logger/Logger.html) is the idiomatic way
+to add logging into elixir code. Logger has a plug-in model,
+allowing for different logging [Backends](https://hexdocs.pm/logger/Logger.html#module-backends)
+to be used without the need to change the logging code within your project.
+
+This approach will benefit from the fact that most elixir libs and frameworks
+are likely to use the elixir Logger and as such logging will all flow via the
+same logging mechanism.
+
+In [elixir 1.5 support for parse transforms was deprecated](https://github.com/elixir-lang/elixir/issues/5762).
+Taking the "Lager as a Logger Backend" approach is likely bypass any related 
+regression issues that would be introduced into a project which is using lager 
+directly when updating to elixir 1.5.
+
+There are open source elixir Logger backends for Lager available:
+- [LagerLogger](https://github.com/PSPDFKit-labs/lager_logger)
+- [LoggerLagerBackend](https://github.com/jonathanperret/logger_lager_backend)
+
+### Directly
+
+It is fully possible prior to elixir 1.5 to use lager and all its features
+directly.
+
+After elixir 1.5 there is no support for parse transforms, and it is
+recommended to use an elixir wrapper for the lager api that provides compile time
+log level exclusion via elixir macros when opting for direct use of lager.
+
+Including Lager as a dependency:
+``` elixir
+# mix.exs
+def application do
+ [
+ applications: [:lager],
+ erl_opts: [parse_transform: "lager_transform"]
+ ]
+end
+
+defp deps do
+ [{:lager, "~> 3.2"}]
+end
+```
+
+Example Configuration:
+``` elixir
+# config.exs
+use Mix.Config
+
+# Stop lager writing a crash log
+config :lager, :crash_log, false
+
+config :lager,
+ log_root: '/var/log/hello',
+ handlers: [
+ lager_console_backend: :info,
+ lager_file_backend: [file: "error.log", level: :error],
+ lager_file_backend: [file: "console.log", level: :info]
+ ]
+```
+
+There is a known issue where Elixir's Logger and Lager both contest for the
+Erlang `error_logger` handle if used side by side.
+
+If using both add the following to your `config.exs`:
+```elixir
+# config.exs
+use Mix.Config
+
+# Stop lager redirecting :error_logger messages
+config :lager, :error_logger_redirect, false
+
+# Stop lager removing Logger's :error_logger handler
+config :lager, :error_logger_whitelist, [Logger.ErrorHandler]
+```
+
+Example Usage:
+``` elixir
+:lager.error('Some message')
+:lager.warning('Some message with a term: ~p', [term])
+```
+
+3.x Changelog
+-------------
+3.9.2 - 14 May 2021
+
+ * Bugfix: Prevent "a term is constructed but never used" warnings (#547)
+ * Bugfix: Update CI test matrix to include OTP 24 (#551)
+
+3.9.1 - 2 March 2021
+
+ * Bugfix: More log_root fun (#543)
+ * Bugfix: Use GHA for all the CIs
+
+3.9.0 - 24 February 2021
+
+ * Bugfix: Try to make a log root of "log" more sensible (#540)
+ * Feature: Further adapt to OTP 24 (also remove pre OTP 21 code),
+ adopt Github Actions for tests
+
+3.8.2 - 4 February 2021
+
+ * Bugfix: Make directory expansion return an absolute path (#535)
+ * Feature: Write crash.log under the log_root location (#536)
+ * Bugfix: Handle line numbering correctly in forthcoming OTP 24 release (#537)
+
+3.8.1 - 28 August 2020
+
+ * Feature: Allow metadata fields to be whitelisted in log formatting (#514)
+ * Feature: Enable a persistent_term log formatter (#530) (#531)
+ * Bugfix: Handle gen_statem crashes in newer OTP releases correctly (#523)
+ * Cleanup: Add a hex badge (#525)
+ * Cleanup: Fix Travis CI badge link
+ * Policy: Officially ending support for OTP 20 (Support OTP 21, 22, 23)
+
+3.8.0 - 9 August 2019
+
+ * Breaking API change: Modify the `lager_rotator_behaviour` to pass in a
+ file's creation time to `ensure_logfile/5` to be used to determine if
+ file has changed on systems where inodes are not available (i.e.
+ `win32`). The return value from `create_logfile/2`, `open_logfile/2` and
+ `ensure_logfile/5` now requires ctime to be returned (#509)
+ * Bugfix: ensure log file rotation works on `win32` (#509)
+ * Bugfix: ensure test suite passes on `win32` (#509)
+ * Bugfix: ensure file paths with Unicode are formatted properly (#510)
+
+3.7.0 - 24 May 2019
+
+ * Policy: Officially ending support for OTP 19 (Support OTP 20, 21, 22)
+ * Cleanup: Fix all dialyzer errors
+ * Bugfix: Minor changes to FSM/statem exits in OTP 22.
+
+3.6.10 - 30 April 2019
+
+ * Documentation: Fix pr_stacktrace invocation example (#494)
+ * Bugfix: Do not count suppressed messages for message drop counts (#499)
+
+3.6.9 - 13 March 2019
+
+ * Bugfix: Fix file rotation on windows (#493)
+
+3.6.8 - 21 December 2018
+
+ * Documentation: Document the error_logger_whitelist environment variable. (#489)
+ * Bugfix: Remove the built in handler inside of OTP 21 `logger` system. (#488)
+ * Bugfix: Cleanup unneeded check for is_map (#486)
+ * Bugfix: Cleanup ranch errors treated as cowboy errors (#485)
+ * Testing: Remove OTP 18 from TravisCI testing matrix
+
+3.6.7 - 14 October 2018
+
+ * Bugfix: fix tracing to work with OTP21 #480
+
+3.6.6 - 24 September 2018
+
+ * Bugfix: When printing records, handle an improper list correctly. #478
+ * Bugfix: Fix various tests and make some rotation code more explicit. #476
+ * Bugfix: Make sure not to miscount messages during high-water mark check. #475
+
+3.6.5 - 3 September 2018
+
+ * Feature: Allow the console backend to redirect output to a remote node #469
+ * Feature: is_loggble - support for severity as atom #472
+ * Bugfix: Prevent silent dropping of messages when hwm is exceeded #467
+ * Bugfix: rotation - default log file not deleted #474
+ * Bugfix: Handle strange crash report from gen_statem #473
+ * Documentation: Various markup fixes: #468 #470
+
+3.6.4 - 11 July 2018
+
+ * Bugfix: Reinstall handlers after a sink is killed #459
+ * Bugfix: Fix platform_define matching not to break on OSX Mojave #461
+ * Feature: Add support for installing a sys trace function #462
+
+3.6.3 - 6 June 2018
+
+ * OTP 21 support
+
+3.6.2 - 26 April 2018
+
+ * Bugfix: flush_threshold not working (#449)
+ * Feature: Add `node` as a formatting option (#447)
+ * Documentation: Update Elixir section with information about parse_transform (#446)
+ * Bugfix: Correct default console configuation to use "[{level,info}]" instead (#445)
+ * Feature: Pretty print lists of records at top level and field values with lager:pr (#442)
+ * Bugfix: Ignore return value of lager:dispatch_log in lager.hrl (#441)
+
+3.6.1 - 1 February 2018
+
+ * Bugfix: Make a few corrections to the recent mailbox flushing changes (#436)
+ * Bugfix: add flush options to proplist validation (#439)
+ * Bugfix: Don't log when we dropped 0 messages (#440)
+
+3.6.0 - 16 January 2018
+
+ * Feature: Support logging with macros per level (#419)
+ * Feature: Support custom file rotation handler; support hourly file
+ rotation (#420)
+ * Feature: Optionally reverse pretty stacktraces (so errors are
+ at the top and the failed function call is at the bottom.)
+ (#424)
+ * Bugfix: Handle OTP 20 gen_server failure where client pid
+ is dead. (#426)
+ * Feature: Optionally don't flush notify messages at
+ high water mark. (#427)
+ * Bugfix: Handle another stacktrace format (#429)
+ * Bugfix: Fix test failure using macros on OTP 18 (#430)
+ * Policy: Remove all code which supports R15 (#432)
+
+3.5.2 - 19 October 2017
+
+ * Bugfix: Properly check for unicode characters in potentially deep
+ character list. (#417)
+
+3.5.1 - 15 June 2017
+
+ * Doc fix: Missed a curly brace in an example. (#412)
+ * Feature: Dynamic metadata functions (#392) - It is now possible to
+ dynamically add metadata to lager messages. See the "dynamic
+ metadata" section above for more information.
+ * Doc fix: Add information about the "application" placeholder. (#414)
+
+3.5.0 - 28 May 2017
+
+ * Bugfix: Support OTP 20 gen_event messages (#410)
+ * Feature: Enable console output to standard_error.
+ Convert to proplist configuration style (like file handler)
+ Deprecate previous configuration directives (#409)
+ * Bugfix: Enable the event shaper to filter messages before they're
+ counted; do not count application/supervisor start/stops
+ toward high water mark. (#411)
+ * Docs: Add PR guidelines; add info about the #lager chat room on freenode.
+
+3.4.2 - 26 April 2017
+
+ * Docs: Document how to make lager use UTC timestamps (#405)
+ * Docs: Add a note about our triage cadence.
+ * Docs: Update lager_syslog URL
+ * Docs: Document placeholders for error_logger integration (#404)
+ * Feature: Add hex.pm metadata and full rebar3 support.
+
+3.4.1 - 28 March 2017
+
+ * Docs: Added documentation around using lager in the context of elixir applications (#398)
+ * Bugfix: Properly expand paths when log_root is set. (#386)
+ * Policy: Removed R15 from Travis configuration
+
+3.4.0 - 16 March 2017
+
+ * Policy: Adopt official OTP support policy. (This is the **last** lager 3.x release
+ that will support R15.)
+ * Test: Fix timeouts, R15 missing functions on possibly long-running tests in Travis. (#394, #395)
+ * Feature: capture and log metadata from error_logger messages (#397)
+ * Feature: Expose new trace filters and enable filter composition (#389)
+ * Feature: Log crashes from gen_fsm and gen_statem correctly (#391)
+ * Docs: Typo in badge URL (#390)
+
+3.3.0 - 16 February 2017
+
+ * Docs: Fix documentation to make 'it' unambiguous when discussing asychronous
+ operation. (#387)
+ * Test: Fix test flappiness due to insufficient sanitation between test runs (#384, #385)
+ * Feature: Allow metadata only logging. (#380)
+ * Feature: Add an upper case severity formatter (#372)
+ * Feature: Add support for suppressing start/stop messages from supervisors (#368)
+ * Bugfix: Fix ranch crash messages (#366)
+ * Test: Update Travis config for 18.3 and 19.0 (#365)
+
+3.2.4 - 11 October 2016
+
+ * Test: Fix dialyzer warnings.
+
+3.2.3 - 29 September 2016
+
+ * Dependency: Update to goldrush 0.19
+
+3.2.2 - 22 September 2016
+
+ * Bugfix: Backwards-compatibility fix for `{crash_log, undefined}` (#371)
+ * Fix documentation/README to reflect the preference for using `false`
+ as the `crash_log` setting value rather than `undefined` to indicate
+ that the crash log should not be written (#364)
+ * Bugfix: Backwards-compatibility fix for `lager_file_backend` "legacy"
+ configuration format (#374)
+
+3.2.1 - 10 June 2016
+
+ * Bugfix: Recent `get_env` changes resulted in launch failure (#355)
+ * OTP: Support typed records for Erlang 19.0 (#361)
+
+3.2.0 - 08 April 2016
+
+ * Feature: Optional sink killer to shed load when mailbox size exceeds a
+ configurable high water mark (#346)
+ * Feature: Export `configure_sink/2` so users may dynamically configure
+ previously setup and parse transformed sinks from their own code. (#342)
+ * Feature: Re-enable Travis CI and update .travis.yml (#340)
+ * Bugfix: Fix test race conditions for Travis CI (#344)
+ * Bugfix: Add the atom 'none' to the log_level() type so downstream
+ users won't get dialyzer failures if they use the 'none' log level. (#343)
+ * Bugfix: Fix typo in documentation. (#341)
+ * Bugfix: Fix OTP 18 test failures due to `warning_map/0` response
+ change. (#337)
+ * Bugfix: Make sure traces that use the file backend work correctly
+ when specified in lager configuration. (#336)
+ * Bugfix: Use `lager_app:get_env/3` for R15 compatibility. (#335)
+ * Bugfix: Make sure lager uses `id` instead of `name` when reporting
+ supervisor children failures. (The atom changed in OTP in 2014.) (#334)
+ * Bugfix: Make lager handle improper iolists (#327)
+
+3.1.0 - 27 January 2016
+
+ * Feature: API calls to a rotate handler, sink or all. This change
+ introduces a new `rotate` message for 3rd party lager backends; that's
+ why this is released as a new minor version number. (#311)
+
+3.0.3 - 27 January 2016
+
+ * Feature: Pretty printer for human readable stack traces (#298)
+ * Feature: Make error reformatting optional (#305)
+ * Feature: Optional and explicit sink for error_logger messages (#303)
+ * Bugfix: Always explicitly close a file after its been rotated (#316)
+ * Bugfix: If a relative path already contains the log root, do not add it again (#317)
+ * Bugfix: Configure and start extra sinks before traces are evaluated (#307)
+ * Bugfix: Stop and remove traces correctly (#306)
+ * Bugfix: A byte value of 255 is valid for Unicode (#300)
+ * Dependency: Bump to goldrush 0.1.8 (#313)

guam-0.9.11.tar.gz/_checkouts/lager/hex_metadata.config Added

@@ -0,0 +1,27 @@
+{<<"app">>,<<"lager">>}.
+{<<"build_tools">>,[<<"rebar3">>]}.
+{<<"description">>,<<"Erlang logging framework">>}.
+{<<"files">>,
+ [<<"LICENSE">>,<<"README.md">>,<<"include/lager.hrl">>,<<"priv/edoc.css">>,
+ <<"rebar.config">>,<<"rebar.config.script">>,<<"rebar.lock">>,
+ <<"src/error_logger_lager_h.erl">>,<<"src/lager.app.src">>,
+ <<"src/lager.erl">>,<<"src/lager_app.erl">>,
+ <<"src/lager_backend_throttle.erl">>,
+ <<"src/lager_common_test_backend.erl">>,<<"src/lager_config.erl">>,
+ <<"src/lager_console_backend.erl">>,<<"src/lager_crash_log.erl">>,
+ <<"src/lager_default_formatter.erl">>,<<"src/lager_file_backend.erl">>,
+ <<"src/lager_format.erl">>,<<"src/lager_handler_watcher.erl">>,
+ <<"src/lager_handler_watcher_sup.erl">>,<<"src/lager_manager_killer.erl">>,
+ <<"src/lager_msg.erl">>,<<"src/lager_rotator_behaviour.erl">>,
+ <<"src/lager_rotator_default.erl">>,<<"src/lager_stdlib.erl">>,
+ <<"src/lager_sup.erl">>,<<"src/lager_transform.erl">>,
+ <<"src/lager_trunc_io.erl">>,<<"src/lager_util.erl">>]}.
+{<<"licenses">>,[<<"Apache 2">>]}.
+{<<"links">>,[{<<"Github">>,<<"https://github.com/erlang-lager/lager">>}]}.
+{<<"name">>,<<"lager">>}.
+{<<"requirements">>,
+ [{<<"goldrush">>,
+ [{<<"app">>,<<"goldrush">>},
+ {<<"optional">>,false},
+ {<<"requirement">>,<<"0.1.9">>}]}]}.
+{<<"version">>,<<"3.9.2">>}.

guam-0.9.11.tar.gz/_checkouts/lager/include Added

guam-0.9.11.tar.gz/_checkouts/lager/include/lager.hrl Added

@@ -0,0 +1,178 @@
+%% Copyright (c) 2011-2012 Basho Technologies, Inc.  All Rights Reserved.
+%%
+%% This file is provided to you 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.
+
+
+-define(DEFAULT_TRUNCATION, 4096).
+-define(DEFAULT_TRACER, lager_default_tracer).
+-define(DEFAULT_SINK, lager_event).
+-define(ERROR_LOGGER_SINK, error_logger_lager_event).
+
+-define(METADATA(Extras), [{severity, info},
+                           {pid, self()},
+                           {node, node()},
+                           {module, ?MODULE},
+                           {function, ?FUNCTION_NAME},
+                           {function_arity, ?FUNCTION_ARITY},
+                           {file, ?FILE},
+                           {line, ?LINE} | Extras]).
+
+-define(lager_log(Severity, Format, Args, Safety),
+        ?lager_log(?DEFAULT_SINK, Severity, ?METADATA(lager:md()), Format, Args,
+                   ?DEFAULT_TRUNCATION, Safety)).
+-define(lager_log(Severity, Metadata, Format, Args, Safety),
+        ?lager_log(?DEFAULT_SINK, Severity, ?METADATA(Metadata++lager:md()), Format, Args,
+                   ?DEFAULT_TRUNCATION, Safety)).
+
+-define(lager_log(Sink, Severity, Metadata, Format, Args, Size, Safety),
+        _ = lager:dispatch_log(Sink, Severity, Metadata, Format, Args, Size, Safety)).
+
+-define(lager_debug(Format, Args), ?lager_log(debug, Format, Args, safe)).
+-define(lager_debug(Metadata, Format, Args), ?lager_log(debug, Metadata, Format, Args, safe)).
+
+-define(lager_info(Format, Args), ?lager_log(info, Format, Args, safe)).
+-define(lager_info(Metadata, Format, Args), ?lager_log(info, Metadata, Format, Args, safe)).
+
+-define(lager_notice(Format, Args), ?lager_log(notice, Format, Args, safe)).
+-define(lager_notice(Metadata, Format, Args), ?lager_log(notice, Metadata, Format, Args, safe)).
+
+-define(lager_warning(Format, Args), ?lager_log(warning, Format, Args, safe)).
+-define(lager_warning(Metadata, Format, Args), ?lager_log(warning, Metadata, Format, Args, safe)).
+
+-define(lager_error(Format, Args), ?lager_log(error, Format, Args, safe)).
+-define(lager_error(Metadata, Format, Args), ?lager_log(error, Metadata, Format, Args, safe)).
+
+-define(lager_critical(Format, Args), ?lager_log(critical, Format, Args, safe)).
+-define(lager_critical(Metadata, Format, Args), ?lager_log(critical, Metadata, Format, Args, safe)).
+
+-define(lager_alert(Format, Args), ?lager_log(alert, Format, Args, safe)).
+-define(lager_alert(Metadata, Format, Args), ?lager_log(alert, Metadata, Format, Args, safe)).
+
+-define(lager_emergency(Format, Args), ?lager_log(emergency, Format, Args, safe)).
+-define(lager_emergency(Metadata, Format, Args), ?lager_log(emergency, Metadata, Format, Args, safe)).
+
+-define(lager_none(Format, Args), ?lager_log(none, Format, Args, safe)).
+-define(lager_none(Metadata, Format, Args), ?lager_log(none, Metadata, Format, Args, safe)).
+
+-define(LEVELS,
+    [debug, info, notice, warning, error, critical, alert, emergency, none]).
+
+%% Use of these "functions" means that the argument list will not be
+%% truncated for safety
+-define(LEVELS_UNSAFE,
+    [{debug_unsafe, debug}, {info_unsafe, info}, {notice_unsafe, notice}, {warning_unsafe, warning}, {error_unsafe, error}, {critical_unsafe, critical}, {alert_unsafe, alert}, {emergency_unsafe, emergency}]).
+
+-define(DEBUG, 128).
+-define(INFO, 64).
+-define(NOTICE, 32).
+-define(WARNING, 16).
+-define(ERROR, 8).
+-define(CRITICAL, 4).
+-define(ALERT, 2).
+-define(EMERGENCY, 1).
+-define(LOG_NONE, 0).
+
+-define(LEVEL2NUM(Level),
+    case Level of
+        debug -> ?DEBUG;
+        info -> ?INFO;
+        notice -> ?NOTICE;
+        warning -> ?WARNING;
+        error -> ?ERROR;
+        critical -> ?CRITICAL;
+        alert -> ?ALERT;
+        emergency -> ?EMERGENCY
+    end).
+
+-define(NUM2LEVEL(Num),
+    case Num of
+        ?DEBUG -> debug;
+        ?INFO -> info;
+        ?NOTICE -> notice;
+        ?WARNING -> warning;
+        ?ERROR -> error;
+        ?CRITICAL -> critical;
+        ?ALERT -> alert;
+        ?EMERGENCY -> emergency
+    end).
+
+-define(SHOULD_LOG(Sink, Level),
+    (lager_util:level_to_num(Level) band element(1, lager_config:get({Sink, loglevel}, {?LOG_NONE, []}))) /= 0).
+
+-define(SHOULD_LOG(Level),
+    (lager_util:level_to_num(Level) band element(1, lager_config:get(loglevel, {?LOG_NONE, []}))) /= 0).
+
+-define(NOTIFY(Level, Pid, Format, Args),
+    gen_event:notify(lager_event, {log, lager_msg:new(io_lib:format(Format, Args),
+            Level,
+            [{pid,Pid},{line,?LINE},{file,?FILE},{module,?MODULE}],
+            [])}
+        )).
+
+%% FOR INTERNAL USE ONLY
+%% internal non-blocking logging call
+%% there's some special handing for when we try to log (usually errors) while
+%% lager is still starting.
+-ifdef(TEST).
+-define(INT_LOG(Level, Format, Args),
+    case ?SHOULD_LOG(Level) of
+        true ->
+            ?NOTIFY(Level, self(), Format, Args);
+        _ ->
+            ok
+    end).
+-else.
+-define(INT_LOG(Level, Format, Args),
+    Self = self(),
+    %% do this in a spawn so we don't cause a deadlock calling gen_event:which_handlers
+    %% from a gen_event handler
+    spawn(fun() ->
+            case catch(gen_event:which_handlers(lager_event)) of
+                X when X == []; X == {'EXIT', noproc}; X == [lager_backend_throttle] ->
+                    %% there's no handlers yet or lager isn't running, try again
+                    %% in half a second.
+                    timer:sleep(500),
+                    ?NOTIFY(Level, Self, Format, Args);
+                _ ->
+                    case ?SHOULD_LOG(Level) of
+                        true ->
+                            ?NOTIFY(Level, Self, Format, Args);
+                        _ ->
+                            ok
+                    end
+            end
+    end)).
+-endif.
+
+-record(lager_shaper, {
+                  id :: any(),
+                  %% how many messages per second we try to deliver
+                  hwm = undefined :: 'undefined' | pos_integer(),
+                  %% how many messages we've received this second
+                  mps = 0 :: non_neg_integer(),
+                  %% the current second
+                  lasttime = os:timestamp() :: erlang:timestamp(),
+                  %% count of dropped messages this second
+                  dropped = 0 :: non_neg_integer(),
+                  %% If true, flush notify messages from msg queue at overload
+                  flush_queue = true :: boolean(),
+                  flush_threshold = 0 :: integer(),
+                  %% timer
+                  timer = make_ref() :: reference(),
+                  %% optional filter fun to avoid counting suppressed messages against HWM totals
+                  filter = fun(_) -> false end :: fun()
+                 }).
+
+-type lager_shaper() :: #lager_shaper{}.

guam-0.9.11.tar.gz/_checkouts/lager/priv Added

guam-0.9.11.tar.gz/_checkouts/lager/priv/edoc.css Added

@@ -0,0 +1,130 @@
+/* Baseline rhythm */
+body {
+   font-size: 16px;
+   font-family: Helvetica, sans-serif;
+   margin: 8px;
+}
+
+p {
+   font-size: 1em; /* 16px */
+   line-height: 1.5em; /* 24px */
+   margin: 0 0 1.5em 0;
+}
+
+h1 {
+   font-size: 1.5em; /* 24px */
+   line-height: 1em; /* 24px */
+   margin-top: 1em;
+   margin-bottom: 0em;
+}
+
+h2 {
+   font-size: 1.375em; /* 22px */
+   line-height: 1.0909em; /* 24px */
+   margin-top: 1.0909em;
+   margin-bottom: 0em;
+}
+
+h3 {
+   font-size: 1.25em; /* 20px */
+   line-height: 1.2em; /* 24px */
+   margin-top: 1.2em;
+   margin-bottom: 0em;
+}
+
+h4 {
+   font-size: 1.125em; /* 18px */
+   line-height: 1.3333em; /* 24px */
+   margin-top: 1.3333em;
+   margin-bottom: 0em;
+}
+
+.class-for-16px {
+   font-size: 1em; /* 16px */
+   line-height: 1.5em; /* 24px */
+   margin-top: 1.5em;
+   margin-bottom: 0em;
+}
+
+.class-for-14px {
+   font-size: 0.875em; /* 14px */
+   line-height: 1.7143em; /* 24px */
+   margin-top: 1.7143em;
+   margin-bottom: 0em;
+}
+
+ul {
+   margin: 0 0 1.5em 0;
+}
+
+/* Customizations */
+body {
+   color: #333;
+}
+
+tt, code, pre {
+   font-family: "Andale Mono", "Inconsolata", "Monaco", "DejaVu Sans Mono", monospaced;
+}
+
+tt, code { font-size: 0.875em }
+
+pre {
+   font-size: 0.875em; /* 14px */
+   line-height: 1.7143em; /* 24px */
+   margin: 0 1em 1.7143em;
+   padding: 0 1em;
+   background: #eee;
+}
+
+.navbar img, hr { display: none }
+
+table {
+   border-collapse: collapse;
+}
+
+h1 {
+   border-left: 0.5em solid #fa0;
+   padding-left: 0.5em;
+}
+
+h2.indextitle {
+   font-size: 1.25em; /* 20px */
+   line-height: 1.2em; /* 24px */
+   margin: -8px -8px 0.6em;
+   background-color: #fa0;
+   color: white;
+   padding: 0.3em;
+}
+
+ul.index {
+   list-style: none;
+   margin-left: 0em;
+   padding-left: 0;
+}
+
+ul.index li {
+   display: inline;
+   padding-right: 0.75em
+}
+
+div.spec p {
+   margin-bottom: 0;
+   padding-left: 1.25em;
+   background-color: #eee;
+}
+
+h3.function {
+   border-left: 0.5em solid #fa0;
+   padding-left: 0.5em;
+   background: #fc9;
+}
+a, a:visited, a:hover, a:active { color: #C60 }
+h2 a, h3 a { color: #333 }
+
+i {
+   font-size: 0.875em; /* 14px */
+   line-height: 1.7143em; /* 24px */
+   margin-top: 1.7143em;
+   margin-bottom: 0em;
+   font-style: normal;
+}

guam-0.9.11.tar.gz/_checkouts/lager/rebar.config Added

@@ -0,0 +1,59 @@
+%% -*- erlang -*-
+%% -------------------------------------------------------------------
+%%
+%% Copyright (c) 2011-2015 Basho Technologies, Inc.
+%%
+%% This file is provided to you 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.
+%%
+%% -------------------------------------------------------------------
+
+{erl_opts, [
+    {lager_extra_sinks, ['__lager_test_sink']},
+    {platform_define, "^18", 'FUNCTION_NAME', unavailable},
+    {platform_define, "^18", 'FUNCTION_ARITY', 0},
+    debug_info,
+    report,
+    verbose,
+    warn_deprecated_function,
+    warn_deprecated_type,
+    warn_export_all,
+    warn_export_vars,
+    warn_obsolete_guard,
+    warn_untyped_record,
+    warn_unused_import
+    % do NOT include warnings_as_errors, as rebar includes these options
+    % when compiling for eunit, and at least one test module has code that
+    % is deliberatly broken and will generate an un-maskable warning
+]}.
+
+{erl_first_files, ["src/lager_util.erl"]}.
+
+{eunit_opts, [verbose]}.
+{eunit_compile_opts, [
+    export_all,
+
+    nowarn_untyped_record,
+    nowarn_export_all
+]}.
+
+{deps, [
+    {goldrush, "0.1.9"}
+]}.
+
+{xref_checks, []}.
+{xref_queries, [{"(XC - UC) || (XU - X - B - lager_default_tracer : Mod - erlang:\"(is_map|map_size)\"/1 - maps:to_list/1)", []}]}.
+
+{cover_enabled, true}.
+{edoc_opts, [{stylesheet_file, "./priv/edoc.css"}]}.

guam-0.9.11.tar.gz/_checkouts/lager/rebar.config.script Added

guam-0.9.11.tar.gz/_checkouts/lager/rebar.lock Added

guam-0.9.11.tar.gz/_checkouts/lager/src Added

guam-0.9.11.tar.gz/_checkouts/lager/src/error_logger_lager_h.erl Added

@@ -0,0 +1,794 @@
+%% Copyright (c) 2011-2015 Basho Technologies, Inc. All Rights Reserved.
+%%
+%% This file is provided to you 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.
+
+%% @doc A error_logger backend for redirecting events into lager.
+%% Error messages and crash logs are also optionally written to a crash log.
+
+%% @see lager_crash_log
+
+%% @private
+
+-module(error_logger_lager_h).
+
+-include("lager.hrl").
+
+-behaviour(gen_event).
+
+-export([set_high_water/1]).
+-export([init/1, handle_call/2, handle_event/2, handle_info/2, terminate/2,
+ code_change/3]).
+
+-export([format_reason/1, format_mfa/1, format_args/3]).
+
+-record(state, {
+ sink :: atom(),
+ shaper :: lager_shaper(),
+ %% group leader strategy
+ groupleader_strategy :: handle | ignore | mirror,
+ raw :: boolean()
+ }).
+
+-define(LOGMSG(Sink, Level, Pid, Msg),
+ case ?SHOULD_LOG(Sink, Level) of
+ true ->
+ _ =lager:log(Sink, Level, Pid, Msg, []),
+ logged;
+ _ -> no_log
+ end).
+
+-define(LOGFMT(Sink, Level, Pid, Fmt, Args),
+ case ?SHOULD_LOG(Sink, Level) of
+ true ->
+ _ = lager:log(Sink, Level, Pid, Fmt, Args),
+ logged;
+ _ -> no_log
+ end).
+
+-ifdef(TEST).
+%% Make CRASH synchronous when testing, to avoid timing headaches
+-define(CRASH_LOG(Event),
+ catch(gen_server:call(lager_crash_log, {log, Event}))).
+-else.
+-define(CRASH_LOG(Event),
+ gen_server:cast(lager_crash_log, {log, Event})).
+-endif.
+
+set_high_water(N) ->
+ gen_event:call(error_logger, ?MODULE, {set_high_water, N}, infinity).
+
+-spec init(any()) -> {ok, #state{}}.
+init([HighWaterMark, GlStrategy]) ->
+ Flush = application:get_env(lager, error_logger_flush_queue, true),
+ FlushThr = application:get_env(lager, error_logger_flush_threshold, 0),
+ Shaper = #lager_shaper{hwm=HighWaterMark, flush_queue = Flush, flush_threshold = FlushThr, filter=shaper_fun(), id=?MODULE},
+ Raw = application:get_env(lager, error_logger_format_raw, false),
+ Sink = configured_sink(),
+ {ok, #state{sink=Sink, shaper=Shaper, groupleader_strategy=GlStrategy, raw=Raw}}.
+
+handle_call({set_high_water, N}, #state{shaper=Shaper} = State) ->
+ NewShaper = Shaper#lager_shaper{hwm=N},
+ {ok, ok, State#state{shaper = NewShaper}};
+handle_call(_Request, State) ->
+ {ok, unknown_call, State}.
+
+shaper_fun() ->
+ case {application:get_env(lager, suppress_supervisor_start_stop, false), application:get_env(lager, suppress_application_start_stop, false)} of
+ {false, false} ->
+ fun(_) -> false end;
+ {true, true} ->
+ fun suppress_supervisor_start_and_application_start/1;
+ {false, true} ->
+ fun suppress_application_start/1;
+ {true, false} ->
+ fun suppress_supervisor_start/1
+ end.
+
+suppress_supervisor_start_and_application_start(E) ->
+ suppress_supervisor_start(E) orelse suppress_application_start(E).
+
+suppress_application_start({info_report, _GL, {_Pid, std_info, D}}) when is_list(D) ->
+ lists:member({exited, stopped}, D);
+suppress_application_start({info_report, _GL, {_P, progress, D}}) ->
+ lists:keymember(application, 1, D) andalso lists:keymember(started_at, 1, D);
+suppress_application_start(_) ->
+ false.
+
+suppress_supervisor_start({info_report, _GL, {_P, progress, D}}) ->
+ lists:keymember(started, 1, D) andalso lists:keymember(supervisor, 1, D);
+suppress_supervisor_start(_) ->
+ false.
+
+handle_event(Event, #state{sink=Sink, shaper=Shaper} = State) ->
+ case lager_util:check_hwm(Shaper, Event) of
+ {true, 0, NewShaper} ->
+ eval_gl(Event, State#state{shaper=NewShaper});
+ {true, Drop, #lager_shaper{hwm=Hwm} = NewShaper} when Drop > 0 ->
+ ?LOGFMT(Sink, warning, self(),
+ "lager_error_logger_h dropped ~p messages in the last second that exceeded the limit of ~p messages/sec",
+ [Drop, Hwm]),
+ eval_gl(Event, State#state{shaper=NewShaper});
+ {false, _, #lager_shaper{dropped=D} = NewShaper} ->
+ {ok, State#state{shaper=NewShaper#lager_shaper{dropped=D+1}}}
+ end.
+
+handle_info({shaper_expired, ?MODULE}, #state{sink=Sink, shaper=Shaper} = State) ->
+ case Shaper#lager_shaper.dropped of
+ 0 ->
+ ok;
+ Dropped ->
+ ?LOGFMT(Sink, warning, self(),
+ "lager_error_logger_h dropped ~p messages in the last second that exceeded the limit of ~p messages/sec",
+ [Dropped, Shaper#lager_shaper.hwm])
+ end,
+ {ok, State#state{shaper=Shaper#lager_shaper{dropped=0, mps=0, lasttime=os:timestamp()}}};
+handle_info(_Info, State) ->
+ {ok, State}.
+
+terminate(_Reason, _State) ->
+ ok.
+
+
+code_change(_OldVsn, {state, Shaper, GLStrategy}, _Extra) ->
+ Raw = application:get_env(lager, error_logger_format_raw, false),
+ {ok, #state{
+ sink=configured_sink(),
+ shaper=Shaper,
+ groupleader_strategy=GLStrategy,
+ raw=Raw
+ }};
+code_change(_OldVsn, {state, Sink, Shaper, GLS}, _Extra) ->
+ Raw = application:get_env(lager, error_logger_format_raw, false),
+ {ok, #state{sink=Sink, shaper=Shaper, groupleader_strategy=GLS, raw=Raw}};
+code_change(_OldVsn, State, _Extra) ->
+ {ok, State}.
+
+%% internal functions
+
+configured_sink() ->
+ case proplists:get_value(?ERROR_LOGGER_SINK, application:get_env(lager, extra_sinks, [])) of
+ undefined -> ?DEFAULT_SINK;
+ _ -> ?ERROR_LOGGER_SINK
+ end.
+
+eval_gl(Event, #state{groupleader_strategy=GlStrategy0}=State) when is_pid(element(2, Event)) ->
+ case element(2, Event) of
+ GL when node(GL) =/= node(), GlStrategy0 =:= ignore ->
+ gen_event:notify({error_logger, node(GL)}, Event),
+ {ok, State};
+ GL when node(GL) =/= node(), GlStrategy0 =:= mirror ->
+ gen_event:notify({error_logger, node(GL)}, Event),
+ log_event(Event, State);
+ _ ->
+ log_event(Event, State)
+ end;
+eval_gl(Event, State) ->
+ log_event(Event, State).
+
+log_event(Event, #state{sink=Sink} = State) ->
+ DidLog = case Event of
+ {error, _GL, {Pid, Fmt, Args}} ->
+ FormatRaw = State#state.raw,
+ case {FormatRaw, Fmt} of
+ {false, "** Generic server "++_} ->
+ %% gen_server terminate
+ {Reason, Name} = case Args of
+ [N, _Msg, _State, R] ->
+ {R, N};
+ [N, _Msg, _State, R, _Client] ->
+ %% OTP 20 crash reports where the client pid is dead don't include the stacktrace
+ {R, N};
+ [N, _Msg, _State, R, _Client, _Stacktrace] ->
+ %% OTP 20 crash reports contain the pid of the client and stacktrace
+ %% TODO do something with them
+ {R, N}
+ end,
+ ?CRASH_LOG(Event),
+ {Md, Formatted} = format_reason_md(Reason),
+ ?LOGFMT(Sink, error, [{pid, Pid}, {name, Name} | Md], "gen_server ~w terminated with reason: ~s",
+ [Name, Formatted]);
+ {false, "** State machine "++_} ->
+ %% Check if the terminated process is gen_fsm or gen_statem
+ %% since they generate the same exit message
+ {Type, Name, StateName, Reason} = case Args of
+ [TName, _Msg, TStateName, _StateData, TReason] ->
+ {gen_fsm, TName, TStateName, TReason};
+ %% Handle changed logging in gen_fsm stdlib-3.9 (TPid, ClientArgs)
+ [TName, _Msg, TPid, TStateName, _StateData, TReason | _ClientArgs] when is_pid(TPid), is_atom(TStateName) ->
+ {gen_fsm, TName, TStateName, TReason};
+ %% Handle changed logging in gen_statem stdlib-3.9 (ClientArgs)
+ [TName, _Msg, {TStateName, _StateData}, _ExitType, TReason, _CallbackMode, Stacktrace | _ClientArgs] ->
+ {gen_statem, TName, TStateName, {TReason, Stacktrace}};
+ %% Handle changed logging in gen_statem stdlib-3.9 (ClientArgs)
+ [TName, {TStateName, _StateData}, _ExitType, TReason, _CallbackMode, Stacktrace | _ClientArgs] ->
+ {gen_statem, TName, TStateName, {TReason, Stacktrace}};
+ [TName, _Msg, [{TStateName, _StateData}], _ExitType, TReason, _CallbackMode, Stacktrace | _ClientArgs] ->
+ %% sometimes gen_statem wraps its statename/data in a list for some reason???
+ {gen_statem, TName, TStateName, {TReason, Stacktrace}}
+ end,
+ {Md, Formatted} = format_reason_md(Reason),
+ ?CRASH_LOG(Event),
+ ?LOGFMT(Sink, error, [{pid, Pid}, {name, Name} | Md], "~s ~w in state ~w terminated with reason: ~s",
+ [Type, Name, StateName, Formatted]);
+ {false, "** gen_event handler"++_} ->
+ %% gen_event handler terminate
+ [ID, Name, _Msg, _State, Reason] = Args,
+ {Md, Formatted} = format_reason_md(Reason),
+ ?CRASH_LOG(Event),
+ ?LOGFMT(Sink, error, [{pid, Pid}, {name, Name} | Md], "gen_event ~w installed in ~w terminated with reason: ~s",
+ [ID, Name, Formatted]);
+ {false, "** Cowboy handler"++_} ->
+ %% Cowboy HTTP server error
+ ?CRASH_LOG(Event),
+ case Args of
+ [Module, Function, Arity, _Request, _State] ->
+ %% we only get the 5-element list when its a non-exported function
+ ?LOGFMT(Sink, error, Pid,
+ "Cowboy handler ~p terminated with reason: call to undefined function ~p:~p/~p",
+ [Module, Module, Function, Arity]);
+ [Module, Function, Arity, _Class, Reason | Tail] ->
+ %% any other cowboy error_format list *always* ends with the stacktrace
+ StackTrace = lists:last(Tail),
+ {Md, Formatted} = format_reason_md({Reason, StackTrace}),
+ ?LOGFMT(Sink, error, [{pid, Pid} | Md],
+ "Cowboy handler ~p terminated in ~p:~p/~p with reason: ~s",
+ [Module, Module, Function, Arity, Formatted])
+ end;
+ {false, "Ranch listener "++_} ->
+ %% Ranch errors
+ ?CRASH_LOG(Event),
+ case Args of
+ %% Error logged by cowboy, which starts as ranch error
+ [Ref, ConnectionPid, StreamID, RequestPid, Reason, StackTrace] ->
+ {Md, Formatted} = format_reason_md({Reason, StackTrace}),
+ ?LOGFMT(Sink, error, [{pid, RequestPid} | Md],
+ "Cowboy stream ~p with ranch listener ~p and connection process ~p "
+ "had its request process exit with reason: ~s",
+ [StreamID, Ref, ConnectionPid, Formatted]);
+ [Ref, _Protocol, Worker, {[{reason, Reason}, {mfa, {Module, Function, Arity}}, {stacktrace, StackTrace} | _], _}] ->
+ {Md, Formatted} = format_reason_md({Reason, StackTrace}),
+ ?LOGFMT(Sink, error, [{pid, Worker} | Md],
+ "Ranch listener ~p terminated in ~p:~p/~p with reason: ~s",
+ [Ref, Module, Function, Arity, Formatted]);
+ [Ref, _Protocol, Worker, Reason] ->
+ {Md, Formatted} = format_reason_md(Reason),
+ ?LOGFMT(Sink, error, [{pid, Worker} | Md],
+ "Ranch listener ~p terminated with reason: ~s",
+ [Ref, Formatted]);
+ [Ref, Protocol, Ret] ->
+ %% ranch_conns_sup.erl module line 119-123 has three parameters error msg, log it.
+ {Md, Formatted} = format_reason_md(Ret),
+ ?LOGFMT(Sink, error, [{pid, Protocol} | Md],
+ "Ranch listener ~p terminated with result:~s",
+ [Ref, Formatted])
+ end;
+ {false, "webmachine error"++_} ->
+ %% Webmachine HTTP server error
+ ?CRASH_LOG(Event),
+ [Path, Error] = Args,
+ %% webmachine likes to mangle the stack, for some reason
+ StackTrace = case Error of
+ {error, {error, Reason, Stack}} ->
+ {Reason, Stack};
+ _ ->
+ Error
+ end,
+ {Md, Formatted} = format_reason_md(StackTrace),
+ ?LOGFMT(Sink, error, [{pid, Pid} | Md], "Webmachine error at path ~p : ~s", [Path, Formatted]);
+ _ ->
+ ?CRASH_LOG(Event),
+ ?LOGFMT(Sink, error, Pid, Fmt, Args)
+ end;
+ {error_report, _GL, {Pid, std_error, D}} ->
+ ?CRASH_LOG(Event),
+ ?LOGMSG(Sink, error, Pid, print_silly_list(D));
+ {error_report, _GL, {Pid, supervisor_report, D}} ->
+ ?CRASH_LOG(Event),
+ case lists:sort(D) of
+ [{errorContext, Ctx}, {offender, Off}, {reason, Reason}, {supervisor, Name}] ->
+ Offender = format_offender(Off),
+ {Md, Formatted} = format_reason_md(Reason),
+ ?LOGFMT(Sink, error, [{pid, Pid} | Md],
+ "Supervisor ~w had child ~s exit with reason ~s in context ~w",
+ [supervisor_name(Name), Offender, Formatted, Ctx]);
+ _ ->
+ ?LOGMSG(Sink, error, Pid, "SUPERVISOR REPORT " ++ print_silly_list(D))
+ end;
+ {error_report, _GL, {Pid, crash_report, [Self, Neighbours]}} ->
+ ?CRASH_LOG(Event),
+ {Md, Formatted} = format_crash_report(Self, Neighbours),
+ ?LOGMSG(Sink, error, [{pid, Pid} | Md], "CRASH REPORT " ++ Formatted);
+ {warning_msg, _GL, {Pid, Fmt, Args}} ->
+ ?LOGFMT(Sink, warning, Pid, Fmt, Args);
+ {warning_report, _GL, {Pid, std_warning, Report}} ->
+ ?LOGMSG(Sink, warning, Pid, print_silly_list(Report));
+ {info_msg, _GL, {Pid, Fmt, Args}} ->
+ ?LOGFMT(Sink, info, Pid, Fmt, Args);
+ {info_report, _GL, {Pid, std_info, D}} when is_list(D) ->
+ Details = lists:sort(D),
+ case Details of
+ [{application, App}, {exited, Reason}, {type, _Type}] ->
+ case application:get_env(lager, suppress_application_start_stop, false) of
+ true when Reason == stopped ->
+ no_log;
+ _ ->
+ {Md, Formatted} = format_reason_md(Reason),
+ ?LOGFMT(Sink, info, [{pid, Pid} | Md], "Application ~w exited with reason: ~s",
+ [App, Formatted])
+ end;
+ _ ->
+ ?LOGMSG(Sink, info, Pid, print_silly_list(D))
+ end;
+ {info_report, _GL, {Pid, std_info, D}} ->
+ ?LOGFMT(Sink, info, Pid, "~w", [D]);
+ {info_report, _GL, {P, progress, D}} ->
+ Details = lists:sort(D),
+ case Details of
+ [{application, App}, {started_at, Node}] ->
+ case application:get_env(lager, suppress_application_start_stop, false) of
+ true ->
+ no_log;
+ _ ->
+ ?LOGFMT(Sink, info, P, "Application ~w started on node ~w",
+ [App, Node])
+ end;
+ [{started, Started}, {supervisor, Name}] ->
+ case application:get_env(lager, suppress_supervisor_start_stop, false) of
+ true ->
+ no_log;
+ _ ->
+ MFA = format_mfa(get_value(mfargs, Started)),
+ Pid = get_value(pid, Started),
+ ?LOGFMT(Sink, debug, P, "Supervisor ~w started ~s at pid ~w",
+ [supervisor_name(Name), MFA, Pid])
+ end;
+ _ ->
+ ?LOGMSG(Sink, info, P, "PROGRESS REPORT " ++ print_silly_list(D))
+ end;
+ _ ->
+ ?LOGFMT(Sink, warning, self(), "Unexpected error_logger event ~w", [Event])
+ end,
+ case DidLog of
+ logged ->
+ {ok, State};
+ no_log ->
+ Shaper = State#state.shaper,
+ {ok, State#state{
+ shaper = Shaper#lager_shaper{
+ mps = Shaper#lager_shaper.mps - 1
+ }
+ }
+ }
+ end.
+
+format_crash_report(Report, Neighbours) ->
+ Name = case get_value(registered_name, Report, []) of
+ [] ->
+ %% process_info(Pid, registered_name) returns [] for unregistered processes
+ get_value(pid, Report);
+ Atom -> Atom
+ end,
+ Md0 = case get_value(dictionary, Report, []) of
+ [] ->
+ %% process_info(Pid, registered_name) returns [] for unregistered processes
+ [];
+ Dict ->
+ %% pull the lager metadata out of the process dictionary, if we can
+ get_value('_lager_metadata', Dict, [])
+ end,
+
+ {Class, Reason, Trace} = get_value(error_info, Report),
+ {Md, ReasonStr} = format_reason_md({Reason, Trace}),
+ Type = case Class of
+ exit -> "exited";
+ _ -> "crashed"
+ end,
+ {Md0 ++ Md, io_lib:format("Process ~w with ~w neighbours ~s with reason: ~s",
+ [Name, length(Neighbours), Type, ReasonStr])}.
+
+format_offender(Off) ->
+ case get_value(mfargs, Off) of
+ undefined ->
+ %% supervisor_bridge
+ io_lib:format("at module ~w at ~w",
+ [get_value(mod, Off), get_value(pid, Off)]);
+ MFArgs ->
+ %% regular supervisor
+ {_, MFA} = format_mfa_md(MFArgs),
+
+ %% In 2014 the error report changed from `name' to
+ %% `id', so try that first.
+ Name = case get_value(id, Off) of
+ undefined ->
+ get_value(name, Off);
+ Id ->
+ Id
+ end,
+ io_lib:format("~p started with ~s at ~w",
+ [Name, MFA, get_value(pid, Off)])
+ end.
+
+%% backwards compatability shim
+format_reason(Reason) ->
+ element(2, format_reason_md(Reason)).
+
+-spec format_reason_md(Stacktrace:: any()) -> {Metadata:: [{atom(), any()}], String :: list()}.
+format_reason_md({'function not exported', [{M, F, A},MFA|_]}) ->
+ {Md, Formatted} = format_mfa_md(MFA),
+ {_, Formatted2} = format_mfa_md({M, F, length(A)}),
+ {[{reason, 'function not exported'} | Md],
+ ["call to undefined function ", Formatted2,
+ " from ", Formatted]};
+format_reason_md({'function not exported', [{M, F, A, _Props},MFA|_]}) ->
+ %% R15 line numbers
+ {Md, Formatted} = format_mfa_md(MFA),
+ {_, Formatted2} = format_mfa_md({M, F, length(A)}),
+ {[{reason, 'function not exported'} | Md],
+ ["call to undefined function ", Formatted2,
+ " from ", Formatted]};
+format_reason_md({undef, [MFA|_]}) ->
+ {Md, Formatted} = format_mfa_md(MFA),
+ {[{reason, undef} | Md],
+ ["call to undefined function ", Formatted]};
+format_reason_md({bad_return, {_MFA, {'EXIT', Reason}}}) ->
+ format_reason_md(Reason);
+format_reason_md({bad_return, {MFA, Val}}) ->
+ {Md, Formatted} = format_mfa_md(MFA),
+ {[{reason, bad_return} | Md],
+ ["bad return value ", print_val(Val), " from ", Formatted]};
+format_reason_md({bad_return_value, Val}) ->
+ {[{reason, bad_return}],
+ ["bad return value: ", print_val(Val)]};
+format_reason_md({{bad_return_value, Val}, MFA}) ->
+ {Md, Formatted} = format_mfa_md(MFA),
+ {[{reason, bad_return_value} | Md],
+ ["bad return value: ", print_val(Val), " in ", Formatted]};
+format_reason_md({{badrecord, Record}, [MFA|_]}) ->
+ {Md, Formatted} = format_mfa_md(MFA),
+ {[{reason, badrecord} | Md],
+ ["bad record ", print_val(Record), " in ", Formatted]};
+format_reason_md({{case_clause, Val}, [MFA|_]}) ->
+ {Md, Formatted} = format_mfa_md(MFA),
+ {[{reason, case_clause} | Md],
+ ["no case clause matching ", print_val(Val), " in ", Formatted]};
+format_reason_md({function_clause, [MFA|_]}) ->
+ {Md, Formatted} = format_mfa_md(MFA),
+ {[{reason, function_clause} | Md],
+ ["no function clause matching ", Formatted]};
+format_reason_md({if_clause, [MFA|_]}) ->
+ {Md, Formatted} = format_mfa_md(MFA),
+ {[{reason, if_clause} | Md],
+ ["no true branch found while evaluating if expression in ", Formatted]};
+format_reason_md({{try_clause, Val}, [MFA|_]}) ->
+ {Md, Formatted} = format_mfa_md(MFA),
+ {[{reason, try_clause} | Md],
+ ["no try clause matching ", print_val(Val), " in ", Formatted]};
+format_reason_md({badarith, [MFA|_]}) ->
+ {Md, Formatted} = format_mfa_md(MFA),
+ {[{reason, badarith} | Md],
+ ["bad arithmetic expression in ", Formatted]};
+format_reason_md({{badmatch, Val}, [MFA|_]}) ->
+ {Md, Formatted} = format_mfa_md(MFA),
+ {[{reason, badmatch} | Md],
+ ["no match of right hand value ", print_val(Val), " in ", Formatted]};
+format_reason_md({emfile, _Trace}) ->
+ {[{reason, emfile}],
+ "maximum number of file descriptors exhausted, check ulimit -n"};
+format_reason_md({system_limit, [{M, F, _}|_] = Trace}) ->
+ Limit = case {M, F} of
+ {erlang, open_port} ->
+ "maximum number of ports exceeded";
+ {erlang, spawn} ->
+ "maximum number of processes exceeded";
+ {erlang, spawn_opt} ->
+ "maximum number of processes exceeded";
+ {erlang, list_to_atom} ->
+ "tried to create an atom larger than 255, or maximum atom count exceeded";
+ {ets, new} ->
+ "maximum number of ETS tables exceeded";
+ _ ->
+ {Str, _} = lager_trunc_io:print(Trace, 500),
+ Str
+ end,
+ {[{reason, system_limit}], ["system limit: ", Limit]};
+format_reason_md({badarg, [MFA,MFA2|_]}) ->
+ case MFA of
+ {_M, _F, A, _Props} when is_list(A) ->
+ %% R15 line numbers
+ {Md, Formatted} = format_mfa_md(MFA2),
+ {_, Formatted2} = format_mfa_md(MFA),
+ {[{reason, badarg} | Md],
+ ["bad argument in call to ", Formatted2, " in ", Formatted]};
+ {_M, _F, A} when is_list(A) ->
+ {Md, Formatted} = format_mfa_md(MFA2),
+ {_, Formatted2} = format_mfa_md(MFA),
+ {[{reason, badarg} | Md],
+ ["bad argument in call to ", Formatted2, " in ", Formatted]};
+ _ ->
+ %% seems to be generated by a bad call to a BIF
+ {Md, Formatted} = format_mfa_md(MFA),
+ {[{reason, badarg} | Md],
+ ["bad argument in ", Formatted]}
+ end;
+format_reason_md({{badarg, Stack}, _}) ->
+ format_reason_md({badarg, Stack});
+format_reason_md({{badarity, {Fun, Args}}, [MFA|_]}) ->
+ {arity, Arity} = lists:keyfind(arity, 1, erlang:fun_info(Fun)),
+ {Md, Formatted} = format_mfa_md(MFA),
+ {[{reason, badarity} | Md],
+ [io_lib:format("fun called with wrong arity of ~w instead of ~w in ",
+ [length(Args), Arity]), Formatted]};
+format_reason_md({noproc, MFA}) ->
+ {Md, Formatted} = format_mfa_md(MFA),
+ {[{reason, noproc} | Md],
+ ["no such process or port in call to ", Formatted]};
+format_reason_md({{badfun, Term}, [MFA|_]}) ->
+ {Md, Formatted} = format_mfa_md(MFA),
+ {[{reason, badfun} | Md],
+ ["bad function ", print_val(Term), " in ", Formatted]};
+format_reason_md({Reason, [{M, F, A}|_]}) when is_atom(M), is_atom(F), is_integer(A) ->
+ {Md, Formatted} = format_reason_md(Reason),
+ {_, Formatted2} = format_mfa_md({M, F, A}),
+ {Md, [Formatted, " in ", Formatted2]};
+format_reason_md({Reason, [{M, F, A, Props}|_]}) when is_atom(M), is_atom(F), is_integer(A), is_list(Props) ->
+ %% line numbers
+ {Md, Formatted} = format_reason_md(Reason),
+ {_, Formatted2} = format_mfa_md({M, F, A, Props}),
+ {Md, [Formatted, " in ", Formatted2]};
+format_reason_md(Reason) ->
+ {Str, _} = lager_trunc_io:print(Reason, 500),
+ {[], Str}.
+
+%% backwards compatability shim
+format_mfa(MFA) ->
+ element(2, format_mfa_md(MFA)).
+
+-spec format_mfa_md(any()) -> {[{atom(), any()}], list()}.
+format_mfa_md({M, F, A}) when is_list(A) ->
+ {FmtStr, Args} = format_args(A, [], []),
+ {[{module, M}, {function, F}], io_lib:format("~w:~w("++FmtStr++")", [M, F | Args])};
+format_mfa_md({M, F, A}) when is_integer(A) ->
+ {[{module, M}, {function, F}], io_lib:format("~w:~w/~w", [M, F, A])};
+format_mfa_md({M, F, A, Props}) when is_list(Props) ->
+ case get_value(line, Props) of
+ undefined ->
+ format_mfa_md({M, F, A});
+ Line ->
+ {Md, Formatted} = format_mfa_md({M, F, A}),
+ {[{line, Line} | Md], [Formatted, io_lib:format(" line ~w", [Line])]}
+ end;
+format_mfa_md([{M, F, A}| _]) ->
+ %% this kind of weird stacktrace can be generated by a uncaught throw in a gen_server
+ format_mfa_md({M, F, A});
+format_mfa_md([{M, F, A, Props}| _]) when is_list(Props) ->
+ %% this kind of weird stacktrace can be generated by a uncaught throw in a gen_server
+ %% TODO we might not always want to print the first MFA we see here, often it is more helpful
+ %% to print a lower one, but it is hard to programatically decide.
+ format_mfa_md({M, F, A, Props});
+format_mfa_md(Other) ->
+ {[], io_lib:format("~w", [Other])}.
+
+format_args([], FmtAcc, ArgsAcc) ->
+ {string:join(lists:reverse(FmtAcc), ", "), lists:reverse(ArgsAcc)};
+format_args([H|T], FmtAcc, ArgsAcc) ->
+ {Str, _} = lager_trunc_io:print(H, 100),
+ format_args(T, ["~s"|FmtAcc], [Str|ArgsAcc]).
+
+print_silly_list(L) when is_list(L) ->
+ case lager_stdlib:string_p(L) of
+ true ->
+ lager_trunc_io:format("~s", [L], ?DEFAULT_TRUNCATION);
+ _ ->
+ print_silly_list(L, [], [])
+ end;
+print_silly_list(L) ->
+ {Str, _} = lager_trunc_io:print(L, ?DEFAULT_TRUNCATION),
+ Str.
+
+print_silly_list([], Fmt, Acc) ->
+ lager_trunc_io:format(string:join(lists:reverse(Fmt), ", "),
+ lists:reverse(Acc), ?DEFAULT_TRUNCATION);
+print_silly_list([{K,V}|T], Fmt, Acc) ->
+ print_silly_list(T, ["~p: ~p" | Fmt], [V, K | Acc]);
+print_silly_list([H|T], Fmt, Acc) ->
+ print_silly_list(T, ["~p" | Fmt], [H | Acc]).
+
+print_val(Val) ->
+ {Str, _} = lager_trunc_io:print(Val, 500),
+ Str.
+
+
+%% @doc Faster than proplists, but with the same API as long as you don't need to
+%% handle bare atom keys
+get_value(Key, Value) ->
+ get_value(Key, Value, undefined).
+
+get_value(Key, List, Default) ->
+ case lists:keyfind(Key, 1, List) of
+ false -> Default;
+ {Key, Value} -> Value
+ end.
+
+supervisor_name({local, Name}) -> Name;
+supervisor_name(Name) -> Name.
+
+-ifdef(TEST).
+-include_lib("eunit/include/eunit.hrl").
+
+no_silent_hwm_drops_test_() ->
+ {timeout, 10000,
+ [
+ fun() ->
+ error_logger:tty(false),
+ application:load(lager),
+ application:set_env(lager, handlers, [{lager_test_backend, warning}]),
+ application:set_env(lager, error_logger_redirect, true),
+ application:set_env(lager, error_logger_hwm, 5),
+ application:set_env(lager, error_logger_flush_queue, false),
+ application:set_env(lager, suppress_supervisor_start_stop, true),
+ application:set_env(lager, suppress_application_start_stop, true),
+ application:unset_env(lager, crash_log),
+ lager:start(),
+ try
+ {_, _, MS} = os:timestamp(),
+ timer:sleep((1000000 - MS) div 1000 + 1),
+ % start close to the beginning of a new second
+ [error_logger:error_msg("Foo ~p~n", [K]) || K <- lists:seq(1, 15)],
+ wait_for_message("lager_error_logger_h dropped 10 messages in the last second that exceeded the limit of 5 messages/sec", 100, 50),
+ % and once again
+ [error_logger:error_msg("Foo1 ~p~n", [K]) || K <- lists:seq(1, 20)],
+ wait_for_message("lager_error_logger_h dropped 15 messages in the last second that exceeded the limit of 5 messages/sec", 100, 50)
+ after
+ application:stop(lager),
+ application:stop(goldrush),
+ error_logger:tty(true)
+ end
+ end
+ ]
+ }.
+
+shaper_does_not_forward_sup_progress_messages_to_info_level_backend_test_() ->
+ {timeout, 10000,
+ [fun() ->
+ error_logger:tty(false),
+ application:load(lager),
+ application:set_env(lager, handlers, [{lager_test_backend, info}]),
+ application:set_env(lager, error_logger_redirect, true),
+ application:set_env(lager, error_logger_hwm, 5),
+ application:set_env(lager, suppress_supervisor_start_stop, false),
+ application:set_env(lager, suppress_application_start_stop, false),
+ application:unset_env(lager, crash_log),
+ lager:start(),
+ try
+ PidPlaceholder = self(),
+ SupervisorMsg =
+ [{supervisor, {PidPlaceholder,rabbit_connection_sup}},
+ {started,
+ [{pid, PidPlaceholder},
+ {name,helper_sup},
+ {mfargs,
+ {rabbit_connection_helper_sup,start_link,[]}},
+ {restart_type,intrinsic},
+ {shutdown,infinity},
+ {child_type,supervisor}]}],
+ ApplicationExit =
+ [{application, error_logger_lager_h_test},
+ {exited, stopped},
+ {type, permanent}],
+
+ error_logger:info_report("This is not a progress message"),
+ error_logger:info_report(ApplicationExit),
+ [error_logger:info_report(progress, SupervisorMsg) || _K <- lists:seq(0, 100)],
+ error_logger:info_report("This is not a progress message 2"),
+
+ % Note: this gets logged in slow environments:
+ % Application lager started on node nonode@nohost
+ wait_for_count(fun lager_test_backend:count/0, [3, 4], 100, 50),
+ % Note: this debug msg gets ignored in slow environments:
+ % Lager installed handler lager_test_backend into lager_event
+ wait_for_count(fun lager_test_backend:count_ignored/0, [0, 1], 100, 50)
+ after
+ application:stop(lager),
+ application:stop(goldrush),
+ error_logger:tty(true)
+ end
+ end
+ ]
+ }.
+
+supressed_messages_are_not_counted_for_hwm_test_() ->
+ {timeout, 10000,
+ [fun() ->
+ error_logger:tty(false),
+ application:load(lager),
+ application:set_env(lager, handlers, [{lager_test_backend, debug}]),
+ application:set_env(lager, error_logger_redirect, true),
+ application:set_env(lager, error_logger_hwm, 5),
+ application:set_env(lager, suppress_supervisor_start_stop, true),
+ application:set_env(lager, suppress_application_start_stop, true),
+ application:unset_env(lager, crash_log),
+ lager:start(),
+ try
+ PidPlaceholder = self(),
+ SupervisorMsg =
+ [{supervisor, {PidPlaceholder,rabbit_connection_sup}},
+ {started,
+ [{pid, PidPlaceholder},
+ {name,helper_sup},
+ {mfargs,
+ {rabbit_connection_helper_sup,start_link,[]}},
+ {restart_type,intrinsic},
+ {shutdown,infinity},
+ {child_type,supervisor}]}],
+ ApplicationExit =
+ [{application, error_logger_lager_h_test},
+ {exited, stopped},
+ {type, permanent}],
+
+ lager_test_backend:flush(),
+ error_logger:info_report("This is not a progress message"),
+ [error_logger:info_report(ApplicationExit) || _K <- lists:seq(0, 100)],
+ [error_logger:info_report(progress, SupervisorMsg) || _K <- lists:seq(0, 100)],
+ error_logger:info_report("This is not a progress message 2"),
+
+ wait_for_count(fun lager_test_backend:count/0, 2, 100, 50),
+ wait_for_count(fun lager_test_backend:count_ignored/0, 0, 100, 50)
+ after
+ application:stop(lager),
+ application:stop(goldrush),
+ error_logger:tty(true)
+ end
+ end
+ ]
+ }.
+
+wait_for_message(Expected, Tries, Sleep) ->
+ maybe_find_expected_message(lager_test_backend:get_buffer(), Expected, Tries, Sleep).
+
+maybe_find_expected_message(_Buffer, Expected, 0, _Sleep) ->
+ throw({not_found, Expected});
+maybe_find_expected_message([], Expected, Tries, Sleep) ->
+ timer:sleep(Sleep),
+ maybe_find_expected_message(lager_test_backend:get_buffer(), Expected, Tries - 1, Sleep);
+maybe_find_expected_message([{_Severity, _Date, Msg, _Metadata}|T], Expected, Tries, Sleep) ->
+ case lists:flatten(Msg) of
+ Expected ->
+ ok;
+ _ ->
+ maybe_find_expected_message(T, Expected, Tries, Sleep)
+ end.
+
+wait_for_count(Fun, _Expected, 0, _Sleep) ->
+ Actual = Fun(),
+ Msg = io_lib:format("wait_for_count: fun ~p final value: ~p~n", [Fun, Actual]),
+ throw({failed, Msg});
+wait_for_count(Fun, Expected, Tries, Sleep) when is_list(Expected) ->
+ Actual = Fun(),
+ case lists:member(Actual, Expected) of
+ true ->
+ ok;
+ false ->
+ timer:sleep(Sleep),
+ wait_for_count(Fun, Expected, Tries - 1, Sleep)
+ end;
+wait_for_count(Fun, Expected, Tries, Sleep) ->
+ case Fun() of
+ Expected ->
+ ok;
+ _ ->
+ timer:sleep(Sleep),
+ wait_for_count(Fun, Expected, Tries - 1, Sleep)
+ end.
+-endif.

guam-0.9.11.tar.gz/_checkouts/lager/src/lager.app.src Added

@@ -0,0 +1,30 @@
+{application,lager,
+             [{description,"Erlang logging framework"},
+              {vsn,"3.9.2"},
+              {modules,[]},
+              {applications,[kernel,stdlib,goldrush]},
+              {registered,[lager_sup,lager_event,lager_crash_log,
+                           lager_handler_watcher_sup]},
+              {mod,{lager_app,[]}},
+              {env,[{colored,false},
+                    {colors,[{debug,"\e[0;38m"},
+                             {info,"\e[1;37m"},
+                             {notice,"\e[1;36m"},
+                             {warning,"\e[1;33m"},
+                             {error,"\e[1;31m"},
+                             {critical,"\e[1;35m"},
+                             {alert,"\e[1;44m"},
+                             {emergency,"\e[1;41m"}]},
+                    {log_root,"log"},
+                    {crash_log,"crash.log"},
+                    {crash_log_msg_size,65536},
+                    {crash_log_size,10485760},
+                    {crash_log_date,"$D0"},
+                    {crash_log_count,5},
+                    {crash_log_rotator,lager_rotator_default},
+                    {error_logger_redirect,true},
+                    {error_logger_hwm,50},
+                    {async_threshold,20},
+                    {async_threshold_window,5}]},
+              {licenses,["Apache 2"]},
+              {links,[{"Github","https://github.com/erlang-lager/lager"}]}]}.

guam-0.9.11.tar.gz/_checkouts/lager/src/lager.erl Added

@@ -0,0 +1,746 @@
+%% Copyright (c) 2011-2012 Basho Technologies, Inc. All Rights Reserved.
+%%
+%% This file is provided to you 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.
+
+%% @doc The lager logging framework.
+
+-module(lager).
+
+-include("lager.hrl").
+
+-define(LAGER_MD_KEY, '__lager_metadata').
+-define(TRACE_SINK, '__trace_sink').
+-define(ROTATE_TIMEOUT, 100000).
+
+-ifdef(TEST).
+-include_lib("eunit/include/eunit.hrl").
+-endif.
+
+%% API
+-export([start/0,
+ log/3, log/4, log/5,
+ log_unsafe/4,
+ md/0, md/1,
+ rotate_handler/1, rotate_handler/2, rotate_sink/1, rotate_all/0,
+ trace/2, trace/3, trace_file/2, trace_file/3, trace_file/4, trace_console/1, trace_console/2,
+ install_trace/2, install_trace/3, remove_trace/1, trace_state/3, trace_func/3,
+ list_all_sinks/0, clear_all_traces/0, clear_trace_by_destination/1, stop_trace/1, stop_trace/3, status/0,
+ get_loglevel/1, get_loglevel/2, set_loglevel/2, set_loglevel/3, set_loglevel/4, get_loglevels/1,
+ update_loglevel_config/1, posix_error/1, set_loghwm/2, set_loghwm/3, set_loghwm/4,
+ safe_format/3, safe_format_chop/3, unsafe_format/2, dispatch_log/5, dispatch_log/7, dispatch_log/9,
+ do_log/9, do_log/10, do_log_unsafe/10, pr/2, pr/3, pr_stacktrace/1, pr_stacktrace/2]).
+
+-type log_level() :: none | debug | info | notice | warning | error | critical | alert | emergency.
+-type log_level_number() :: 0..7.
+
+-export_type([log_level/0, log_level_number/0]).
+
+-record(trace_func_state_v1, {
+ pid :: undefined | pid(),
+ level :: log_level(),
+ count :: infinity | pos_integer(),
+ format_string :: string(),
+ timeout :: infinity | pos_integer(),
+ started = os:timestamp() :: erlang:timestamp() %% use os:timestamp for compatability
+ }).
+
+%% API
+
+%% @doc installs a lager trace handler into the target process (using sys:install) at the specified level.
+-spec install_trace(pid(), log_level()) -> ok.
+install_trace(Pid, Level) ->
+ install_trace(Pid, Level, []).
+
+-spec install_trace(pid(), log_level(), [{count, infinity | pos_integer()} | {format_string, string()} | {timeout, timeout()}]) -> ok.
+install_trace(Pid, Level, Options) ->
+ sys:install(Pid, {fun ?MODULE:trace_func/3, trace_state(Pid, Level, Options)}).
+
+%% @doc remove a previously installed lager trace handler from the target process.
+-spec remove_trace(pid()) -> ok.
+remove_trace(Pid) ->
+ sys:remove(Pid, fun ?MODULE:trace_func/3).
+
+%% @doc Start the application. Mainly useful for using `-s lager' as a command
+%% line switch to the VM to make lager start on boot.
+start() -> start(lager).
+
+start(App) ->
+ start_ok(App, application:start(App, permanent)).
+
+start_ok(_App, ok) -> ok;
+start_ok(App, {error, {already_started, App}}) -> ok;
+start_ok(App, {error, {not_started, Dep}}) ->
+ ok = start(Dep),
+ start(App);
+start_ok(App, {error, Reason}) ->
+ erlang:error({app_start_failed, App, Reason}).
+
+%% @doc Get lager metadata for current process
+-spec md() -> [{atom(), any()}].
+md() ->
+ case erlang:get(?LAGER_MD_KEY) of
+ undefined -> [];
+ MD -> MD
+ end.
+
+%% @doc Set lager metadata for current process.
+%% Will badarg if you don't supply a list of {key, value} tuples keyed by atoms.
+-spec md([{atom(), any()},...]) -> ok.
+md(NewMD) when is_list(NewMD) ->
+ %% make sure its actually a real proplist
+ case lists:all(
+ fun({Key, _Value}) when is_atom(Key) -> true;
+ (_) -> false
+ end, NewMD) of
+ true ->
+ erlang:put(?LAGER_MD_KEY, NewMD),
+ ok;
+ false ->
+ erlang:error(badarg)
+ end;
+md(_) ->
+ erlang:error(badarg).
+
+
+-spec dispatch_log(atom(), log_level(), list(), string(), list() | none, pos_integer(), safe | unsafe) -> ok | {error, lager_not_running} | {error, {sink_not_configured, atom()}}.
+%% this is the same check that the parse transform bakes into the module at compile time
+%% see lager_transform (lines 173-216)
+dispatch_log(Sink, Severity, Metadata, Format, Args, Size, Safety) when is_atom(Severity)->
+ SeverityAsInt=lager_util:level_to_num(Severity),
+ case {whereis(Sink), whereis(?DEFAULT_SINK), lager_config:get({Sink, loglevel}, {?LOG_NONE, []})} of
+ {undefined, undefined, _} -> {error, lager_not_running};
+ {undefined, _LagerEventPid0, _} -> {error, {sink_not_configured, Sink}};
+ {SinkPid, _LagerEventPid1, {Level, Traces}} when Safety =:= safe andalso ( (Level band SeverityAsInt) /= 0 orelse Traces /= [] ) ->
+ do_log(Severity, Metadata, Format, Args, Size, SeverityAsInt, Level, Traces, Sink, SinkPid);
+ {SinkPid, _LagerEventPid1, {Level, Traces}} when Safety =:= unsafe andalso ( (Level band SeverityAsInt) /= 0 orelse Traces /= [] ) ->
+ do_log_unsafe(Severity, Metadata, Format, Args, Size, SeverityAsInt, Level, Traces, Sink, SinkPid);
+ _ -> ok
+ end.
+
+%% @private Should only be called externally from code generated from the parse transform
+do_log(Severity, Metadata, Format, Args, Size, SeverityAsInt, LevelThreshold, TraceFilters, Sink, SinkPid) when is_atom(Severity) ->
+ FormatFun = fun() -> safe_format_chop(Format, Args, Size) end,
+ do_log_impl(Severity, Metadata, Format, Args, SeverityAsInt, LevelThreshold, TraceFilters, Sink, SinkPid, FormatFun).
+
+do_log_impl(Severity, Metadata, Format, Args, SeverityAsInt, LevelThreshold, TraceFilters, Sink, SinkPid, FormatFun) ->
+ {Destinations, TraceSinkPid} = case TraceFilters of
+ [] ->
+ {[], undefined};
+ _ ->
+ {lager_util:check_traces(Metadata,SeverityAsInt,TraceFilters,[]), whereis(?TRACE_SINK)}
+ end,
+ case (LevelThreshold band SeverityAsInt) /= 0 orelse Destinations /= [] of
+ true ->
+ Msg = case Args of
+ A when is_list(A) ->
+ FormatFun();
+ _ ->
+ Format
+ end,
+ LagerMsg = lager_msg:new(Msg,
+ Severity, Metadata, Destinations),
+ case lager_config:get({Sink, async}, false) of
+ true ->
+ gen_event:notify(SinkPid, {log, LagerMsg});
+ false ->
+ gen_event:sync_notify(SinkPid, {log, LagerMsg})
+ end,
+ case TraceSinkPid /= undefined of
+ true ->
+ gen_event:notify(TraceSinkPid, {log, LagerMsg});
+ false ->
+ ok
+ end;
+ false ->
+ ok
+ end.
+
+%% @private Should only be called externally from code generated from the parse transform
+%% Specifically, it would be level ++ `_unsafe' as in `info_unsafe'.
+do_log_unsafe(Severity, Metadata, Format, Args, _Size, SeverityAsInt, LevelThreshold, TraceFilters, Sink, SinkPid) when is_atom(Severity) ->
+ FormatFun = fun() -> unsafe_format(Format, Args) end,
+ do_log_impl(Severity, Metadata, Format, Args, SeverityAsInt, LevelThreshold, TraceFilters, Sink, SinkPid, FormatFun).
+
+
+%% backwards compatible with beams compiled with lager 1.x
+dispatch_log(Severity, _Module, _Function, _Line, _Pid, Metadata, Format, Args, Size) ->
+ dispatch_log(Severity, Metadata, Format, Args, Size).
+
+%% backwards compatible with beams compiled with lager 2.x
+dispatch_log(Severity, Metadata, Format, Args, Size) ->
+ dispatch_log(?DEFAULT_SINK, Severity, Metadata, Format, Args, Size, safe).
+
+%% backwards compatible with beams compiled with lager 2.x
+do_log(Severity, Metadata, Format, Args, Size, SeverityAsInt, LevelThreshold, TraceFilters, SinkPid) ->
+ do_log(Severity, Metadata, Format, Args, Size, SeverityAsInt,
+ LevelThreshold, TraceFilters, ?DEFAULT_SINK, SinkPid).
+
+
+%% TODO:
+%% Consider making log2/4 that takes the Level, Pid and Message params of log/3
+%% along with a Sink param??
+
+%% @doc Manually log a message into lager without using the parse transform.
+-spec log(log_level(), pid() | atom() | [tuple(),...], list()) -> ok | {error, lager_not_running}.
+log(Level, Pid, Message) when is_pid(Pid); is_atom(Pid) ->
+ dispatch_log(Level, [{pid,Pid}], Message, [], ?DEFAULT_TRUNCATION);
+log(Level, Metadata, Message) when is_list(Metadata) ->
+ dispatch_log(Level, Metadata, Message, [], ?DEFAULT_TRUNCATION).
+
+%% @doc Manually log a message into lager without using the parse transform.
+-spec log(log_level(), pid() | atom() | [tuple(),...], string(), list()) -> ok | {error, lager_not_running}.
+log(Level, Pid, Format, Args) when is_pid(Pid); is_atom(Pid) ->
+ dispatch_log(Level, [{pid,Pid}], Format, Args, ?DEFAULT_TRUNCATION);
+log(Level, Metadata, Format, Args) when is_list(Metadata) ->
+ dispatch_log(Level, Metadata, Format, Args, ?DEFAULT_TRUNCATION).
+
+log_unsafe(Level, Metadata, Format, Args) when is_list(Metadata) ->
+ dispatch_log(?DEFAULT_SINK, Level, Metadata, Format, Args, ?DEFAULT_TRUNCATION, unsafe).
+
+
+%% @doc Manually log a message into lager without using the parse transform.
+-spec log(atom(), log_level(), pid() | atom() | [tuple(),...], string(), list()) -> ok | {error, lager_not_running}.
+log(Sink, Level, Pid, Format, Args) when is_pid(Pid); is_atom(Pid) ->
+ dispatch_log(Sink, Level, [{pid,Pid}], Format, Args, ?DEFAULT_TRUNCATION, safe);
+log(Sink, Level, Metadata, Format, Args) when is_list(Metadata) ->
+ dispatch_log(Sink, Level, Metadata, Format, Args, ?DEFAULT_TRUNCATION, safe).
+
+validate_trace_filters(Filters, Level, Backend) ->
+ Sink = proplists:get_value(sink, Filters, ?DEFAULT_SINK),
+ {Sink,
+ lager_util:validate_trace({
+ proplists:delete(sink, Filters),
+ Level,
+ Backend
+ })
+ }.
+
+trace_file(File, Filter) ->
+ trace_file(File, Filter, debug, []).
+
+trace_file(File, Filter, Level) when is_atom(Level) ->
+ trace_file(File, Filter, Level, []);
+
+trace_file(File, Filter, Options) when is_list(Options) ->
+ trace_file(File, Filter, debug, Options).
+
+trace_file(File, Filter, Level, Options) ->
+ FileName = lager_util:expand_path(File),
+ case validate_trace_filters(Filter, Level, {lager_file_backend, FileName}) of
+ {Sink, {ok, Trace}} ->
+ Handlers = lager_config:global_get(handlers, []),
+ %% check if this file backend is already installed
+ Res = case lager_util:find_file(FileName, Handlers) of
+ false ->
+ %% install the handler
+ LogFileConfig =
+ lists:keystore(level, 1,
+ lists:keystore(file, 1,
+ Options,
+ {file, FileName}),
+ {level, none}),
+ HandlerInfo =
+ lager_app:start_handler(Sink, {lager_file_backend, FileName},
+ LogFileConfig),
+ lager_config:global_set(handlers, [HandlerInfo|Handlers]),
+ {ok, installed};
+ {_Watcher, _Handler, Sink} ->
+ {ok, exists};
+ {_Watcher, _Handler, _OtherSink} ->
+ {error, file_in_use}
+ end,
+ case Res of
+ {ok, _} ->
+ add_trace_to_loglevel_config(Trace, Sink),
+ {ok, {{lager_file_backend, FileName}, Filter, Level}};
+ {error, _} = E ->
+ E
+ end;
+ {_Sink, Error} ->
+ Error
+ end.
+
+trace_console(Filter) ->
+ trace_console(Filter, debug).
+
+trace_console(Filter, Level) ->
+ trace(lager_console_backend, Filter, Level).
+
+trace(Backend, Filter) ->
+ trace(Backend, Filter, debug).
+
+trace({lager_file_backend, File}, Filter, Level) ->
+ trace_file(File, Filter, Level);
+
+trace(Backend, Filter, Level) ->
+ case validate_trace_filters(Filter, Level, Backend) of
+ {Sink, {ok, Trace}} ->
+ add_trace_to_loglevel_config(Trace, Sink),
+ {ok, {Backend, Filter, Level}};
+ {_Sink, Error} ->
+ Error
+ end.
+
+stop_trace(Backend, Filter, Level) ->
+ case validate_trace_filters(Filter, Level, Backend) of
+ {Sink, {ok, Trace}} ->
+ stop_trace_int(Trace, Sink);
+ {_Sink, Error} ->
+ Error
+ end.
+
+stop_trace({Backend, Filter, Level}) ->
+ stop_trace(Backend, Filter, Level).
+
+%% Important: validate_trace_filters orders the arguments of
+%% trace tuples differently than the way outside callers have
+%% the trace tuple.
+%%
+%% That is to say, outside they are represented as 
+%% `{Backend, Filter, Level}'
+%%
+%% and when they come back from validation, they're
+%% `{Filter, Level, Backend}'
+stop_trace_int({_Filter, _Level, Backend} = Trace, Sink) ->
+ {Level, Traces} = lager_config:get({Sink, loglevel}),
+ NewTraces = lists:delete(Trace, Traces),
+ _ = lager_util:trace_filter([ element(1, T) || T <- NewTraces ]),
+ %MinLevel = minimum_loglevel(get_loglevels() ++ get_trace_levels(NewTraces)),
+ lager_config:set({Sink, loglevel}, {Level, NewTraces}),
+ case get_loglevel(Sink, Backend) of
+ none ->
+ %% check no other traces point here
+ case lists:keyfind(Backend, 3, NewTraces) of
+ false ->
+ gen_event:delete_handler(Sink, Backend, []),
+ lager_config:global_set(handlers,
+ lists:keydelete(Backend, 1,
+ lager_config:global_get(handlers)));
+ _ ->
+ ok
+ end;
+ _ ->
+ ok
+ end,
+ ok.
+
+list_all_sinks() ->
+ sets:to_list(
+ lists:foldl(fun({_Watcher, _Handler, Sink}, Set) ->
+ sets:add_element(Sink, Set)
+ end,
+ sets:new(),
+ lager_config:global_get(handlers, []))).
+
+clear_traces_by_sink(Sinks) ->
+ lists:foreach(fun(S) ->
+ {Level, _Traces} =
+ lager_config:get({S, loglevel}),
+ lager_config:set({S, loglevel},
+ {Level, []})
+ end,
+ Sinks).
+
+clear_trace_by_destination(ID) ->
+ Sinks = lists:sort(list_all_sinks()),
+ Traces = find_traces(Sinks),
+ [ stop_trace_int({Filter, Level, Destination}, Sink) || {Sink, {Filter, Level, Destination}} <- Traces, Destination == ID].
+
+
+clear_all_traces() ->
+ Handlers = lager_config:global_get(handlers, []),
+ clear_traces_by_sink(list_all_sinks()),
+ _ = lager_util:trace_filter(none),
+ lager_config:global_set(handlers,
+ lists:filter(
+ fun({Handler, _Watcher, Sink}) ->
+ case get_loglevel(Sink, Handler) of
+ none ->
+ gen_event:delete_handler(Sink, Handler, []),
+ false;
+ _ ->
+ true
+ end
+ end, Handlers)).
+
+find_traces(Sinks) ->
+ lists:foldl(fun(S, Acc) ->
+ {_Level, Traces} = lager_config:get({S, loglevel}),
+ Acc ++ lists:map(fun(T) -> {S, T} end, Traces)
+ end,
+ [],
+ Sinks).
+
+status() ->
+ Handlers = lager_config:global_get(handlers, []),
+ Sinks = lists:sort(list_all_sinks()),
+ Traces = find_traces(Sinks),
+ TraceCount = case length(Traces) of
+ 0 -> 1;
+ N -> N
+ end,
+ Status = ["Lager status:\n",
+ [begin
+ Level = get_loglevel(Sink, Handler),
+ get_sink_handler_status(Sink, Handler, Level)
+ end || {Handler, _Watcher, Sink} <- lists:sort(fun({_, _, S1},
+ {_, _, S2}) -> S1 =< S2 end,
+ Handlers)],
+ "Active Traces:\n",
+ [begin
+ LevelName = case Level of
+ {mask, Mask} ->
+ case lager_util:mask_to_levels(Mask) of
+ [] -> none;
+ Levels -> hd(Levels)
+ end;
+ Num ->
+ lager_util:num_to_level(Num)
+ end,
+ io_lib:format("Tracing messages matching ~p (sink ~s) at level ~p to ~p\n",
+ [Filter, Sink, LevelName, Destination])
+ end || {Sink, {Filter, Level, Destination}} <- Traces],
+ [
+ "Tracing Reductions:\n",
+ case ?DEFAULT_TRACER:info('query') of
+ {null, false} -> "";
+ Query -> io_lib:format("~p~n", [Query])
+ end
+ ],
+ [
+ "Tracing Statistics:\n ",
+ [ begin
+ [" ", atom_to_list(Table), ": ",
+ integer_to_list(?DEFAULT_TRACER:info(Table) div TraceCount),
+ "\n"]
+ end || Table <- [input, output, filter] ]
+ ]],
+ io:put_chars(Status).
+
+get_sink_handler_status(Sink, Handler, Level) ->
+ case Handler of
+ {lager_file_backend, File} ->
+ io_lib:format("File ~ts (~s) at level ~p\n", [File, Sink, Level]);
+ lager_console_backend ->
+ io_lib:format("Console (~s) at level ~p\n", [Sink, Level]);
+ _ ->
+ []
+ end.
+
+%% @doc Set the loglevel for a particular backend.
+set_loglevel(Handler, Level) when is_atom(Level) ->
+ set_loglevel(?DEFAULT_SINK, Handler, undefined, Level).
+
+%% @doc Set the loglevel for a particular backend that has multiple identifiers
+%% (eg. the file backend).
+set_loglevel(Handler, Ident, Level) when is_atom(Level) ->
+ set_loglevel(?DEFAULT_SINK, Handler, Ident, Level).
+
+%% @doc Set the loglevel for a particular sink's backend that potentially has
+%% multiple identifiers. (Use `undefined' if it doesn't have any.)
+set_loglevel(Sink, Handler, Ident, Level) when is_atom(Level) ->
+ HandlerArg = case Ident of
+ undefined -> Handler;
+ _ -> {Handler, Ident}
+ end,
+ Reply = gen_event:call(Sink, HandlerArg, {set_loglevel, Level}, infinity),
+ update_loglevel_config(Sink),
+ Reply.
+
+
+%% @doc Get the loglevel for a particular backend on the default sink. In the case that the backend
+%% has multiple identifiers, the lowest is returned.
+get_loglevel(Handler) ->
+ get_loglevel(?DEFAULT_SINK, Handler).
+
+%% @doc Get the loglevel for a particular sink's backend. In the case that the backend
+%% has multiple identifiers, the lowest is returned.
+get_loglevel(Sink, Handler) ->
+ case gen_event:call(Sink, Handler, get_loglevel, infinity) of
+ {mask, Mask} ->
+ case lager_util:mask_to_levels(Mask) of
+ [] -> none;
+ Levels -> hd(Levels)
+ end;
+ X when is_integer(X) ->
+ lager_util:num_to_level(X);
+ Y -> Y
+ end.
+
+%% @doc Try to convert an atom to a posix error, but fall back on printing the
+%% term if its not a valid posix error code.
+posix_error(Error) when is_atom(Error) ->
+ case erl_posix_msg:message(Error) of
+ "unknown POSIX error" -> atom_to_list(Error);
+ Message -> Message
+ end;
+posix_error(Error) ->
+ safe_format_chop("~p", [Error], ?DEFAULT_TRUNCATION).
+
+%% @private
+get_loglevels(Sink) ->
+ [gen_event:call(Sink, Handler, get_loglevel, infinity) ||
+ Handler <- gen_event:which_handlers(Sink)].
+
+%% @doc Set the loghwm for the default sink.
+set_loghwm(Handler, Hwm) when is_integer(Hwm) ->
+ set_loghwm(?DEFAULT_SINK, Handler, Hwm).
+
+%% @doc Set the loghwm for a particular backend.
+set_loghwm(Sink, Handler, Hwm) when is_integer(Hwm) ->
+ gen_event:call(Sink, Handler, {set_loghwm, Hwm}, infinity).
+
+%% @doc Set the loghwm (log high water mark) for file backends with multiple identifiers
+set_loghwm(Sink, Handler, Ident, Hwm) when is_integer(Hwm) ->
+ gen_event:call(Sink, {Handler, Ident}, {set_loghwm, Hwm}, infinity).
+
+%% @private
+add_trace_to_loglevel_config(Trace, Sink) ->
+ {MinLevel, Traces} = lager_config:get({Sink, loglevel}),
+ case lists:member(Trace, Traces) of
+ false ->
+ NewTraces = [Trace|Traces],
+ _ = lager_util:trace_filter([ element(1, T) || T <- NewTraces]),
+ lager_config:set({Sink, loglevel}, {MinLevel, [Trace|Traces]});
+ _ ->
+ ok
+ end.
+
+%% @doc recalculate min log level
+update_loglevel_config(error_logger) ->
+ %% Not a sink under our control, part of the Erlang logging
+ %% utility that error_logger_lager_h attaches to
+ true;
+update_loglevel_config(Sink) ->
+ {_, Traces} = lager_config:get({Sink, loglevel}, {ignore_me, []}),
+ MinLog = minimum_loglevel(get_loglevels(Sink)),
+ lager_config:set({Sink, loglevel}, {MinLog, Traces}).
+
+%% @private
+minimum_loglevel(Levels) ->
+ lists:foldl(fun({mask, Mask}, Acc) ->
+ Mask bor Acc;
+ (Level, Acc) when is_integer(Level) ->
+ {mask, Mask} = lager_util:config_to_mask(lager_util:num_to_level(Level)),
+ Mask bor Acc;
+ (_, Acc) ->
+ Acc
+ end, 0, Levels).
+
+%% @doc Print the format string `Fmt' with `Args' safely with a size
+%% limit of `Limit'. If the format string is invalid, or not enough
+%% arguments are supplied 'FORMAT ERROR' is printed with the offending
+%% arguments. The caller is NOT crashed.
+
+safe_format(Fmt, Args, Limit) ->
+ safe_format(Fmt, Args, Limit, []).
+
+safe_format(Fmt, Args, Limit, Options) ->
+ try lager_trunc_io:format(Fmt, Args, Limit, Options)
+ catch
+ _:_ -> lager_trunc_io:format("FORMAT ERROR: ~p ~p", [Fmt, Args], Limit)
+ end.
+
+%% @private
+safe_format_chop(Fmt, Args, Limit) ->
+ safe_format(Fmt, Args, Limit, [{chomp, true}]).
+
+%% @private Print the format string `Fmt' with `Args' without a size limit.
+%% This is unsafe because the output of this function is unbounded.
+%%
+%% Log messages with unbounded size will kill your application dead as
+%% OTP mechanisms stuggle to cope with them. So this function is
+%% intended only for messages which have a reasonable bounded
+%% size before they're formatted.
+%%
+%% If the format string is invalid or not enough arguments are
+%% supplied a 'FORMAT ERROR' message is printed instead with the
+%% offending arguments. The caller is NOT crashed.
+unsafe_format(Fmt, Args) ->
+ try io_lib:format(Fmt, Args)
+ catch
+ _:_ -> io_lib:format("FORMAT ERROR: ~p ~p", [Fmt, Args])
+ end.
+
+%% @doc Print a record or a list of records lager found during parse transform
+pr(Record, Module) when is_tuple(Record), is_atom(element(1, Record)) ->
+ pr(Record, Module, []);
+pr(List, Module) when is_list(List) ->
+ pr(List, Module, []);
+pr(Record, _) ->
+ Record.
+
+%% @doc Print a record or a list of records lager found during parse transform
+pr(Record, Module, Options) when is_tuple(Record), is_atom(element(1, Record)), is_list(Options) ->
+ try 
+ case is_record_known(Record, Module) of
+ false ->
+ Record;
+ {RecordName, RecordFields} ->
+ {'$lager_record', RecordName, 
+ zip(RecordFields, tl(tuple_to_list(Record)), Module, Options, [])}
+ end
+ catch
+ error:undef ->
+ Record
+ end;
+pr([Head|Tail], Module, Options) when is_list(Options) ->
+ [pr(Head, Module, Options)|pr(Tail, Module, Options)];
+pr(Record, _, _) ->
+ Record.
+
+zip([FieldName|RecordFields], [FieldValue|Record], Module, Options, ToReturn) when is_list(FieldValue) ->
+ zip(RecordFields, Record, Module, Options,
+ [{FieldName, pr(FieldValue, Module, Options)}|ToReturn]);
+zip([FieldName|RecordFields], [FieldValue|Record], Module, Options, ToReturn) ->
+ Compress = lists:member(compress, Options),
+ case is_tuple(FieldValue) andalso
+ tuple_size(FieldValue) > 0 andalso
+ is_atom(element(1, FieldValue)) andalso
+ is_record_known(FieldValue, Module) of
+ false when Compress andalso FieldValue =:= undefined ->
+ zip(RecordFields, Record, Module, Options, ToReturn);
+ false ->
+ zip(RecordFields, Record, Module, Options, [{FieldName, FieldValue}|ToReturn]);
+ _Else ->
+ F = {FieldName, pr(FieldValue, Module, Options)},
+ zip(RecordFields, Record, Module, Options, [F|ToReturn])
+ end;
+zip([], [], _Module, _Compress, ToReturn) ->
+ lists:reverse(ToReturn).
+
+is_record_known(Record, Module) ->
+ Name = element(1, Record),
+ Attrs = Module:module_info(attributes),
+ case lists:keyfind(lager_records, 1, Attrs) of
+ false -> false;
+ {lager_records, Records} ->
+ case lists:keyfind(Name, 1, Records) of
+ false -> false;
+ {Name, RecordFields} ->
+ case (tuple_size(Record) - 1) =:= length(RecordFields) of
+ false -> false;
+ true -> {Name, RecordFields}
+ end
+ end
+ end.
+
+
+%% @doc Print stacktrace in human readable form
+pr_stacktrace(Stacktrace) ->
+ Stacktrace1 = case application:get_env(lager, reverse_pretty_stacktrace, true) of
+ true ->
+ lists:reverse(Stacktrace);
+ _ ->
+ Stacktrace
+ end,
+ pr_stacktrace_(Stacktrace1).
+
+pr_stacktrace_(Stacktrace) ->
+ Indent = "\n ",
+ lists:foldl(
+ fun(Entry, Acc) ->
+ Acc ++ Indent ++ error_logger_lager_h:format_mfa(Entry)
+ end,
+ [],
+ Stacktrace).
+
+pr_stacktrace(Stacktrace, {Class, Reason}) ->
+ case application:get_env(lager, reverse_pretty_stacktrace, true) of
+ true ->
+ lists:flatten(
+ pr_stacktrace_(lists:reverse(Stacktrace)) ++ "\n" ++ io_lib:format("~s:~p", [Class, Reason]));
+ _ ->
+ lists:flatten(
+ io_lib:format("~s:~p", [Class, Reason]) ++ pr_stacktrace_(Stacktrace))
+ end.
+
+rotate_sink(Sink) ->
+ Handlers = lager_config:global_get(handlers),
+ RotateHandlers = lists:filtermap(
+ fun({Handler,_,S}) when S == Sink -> {true, {Handler, Sink}};
+ (_) -> false 
+ end, 
+ Handlers),
+ rotate_handlers(RotateHandlers).
+
+rotate_all() -> 
+ rotate_handlers(lists:map(fun({H,_,S}) -> {H, S} end,
+ lager_config:global_get(handlers))).
+
+
+rotate_handlers(Handlers) ->
+ [ rotate_handler(Handler, Sink) || {Handler, Sink} <- Handlers ].
+
+
+rotate_handler(Handler) ->
+ Handlers = lager_config:global_get(handlers),
+ case lists:keyfind(Handler, 1, Handlers) of
+ {Handler, _, Sink} -> rotate_handler(Handler, Sink);
+ false -> ok
+ end.
+
+rotate_handler(Handler, Sink) ->
+ gen_event:call(Sink, Handler, rotate, ?ROTATE_TIMEOUT).
+
+%% @private
+trace_func(#trace_func_state_v1{pid=Pid, level=Level, format_string=Fmt}=FuncState, Event, ProcState) ->
+ _ = lager:log(Level, Pid, Fmt, [Event, ProcState]),
+ check_timeout(decrement_count(FuncState)).
+
+%% @private
+trace_state(Pid, Level, Options) ->
+ #trace_func_state_v1{pid=Pid,
+ level=Level,
+ count=proplists:get_value(count, Options, infinity),
+ timeout=proplists:get_value(timeout, Options, infinity),
+ format_string=proplists:get_value(format_string, Options, "TRACE ~p ~p")}.
+
+decrement_count(#trace_func_state_v1{count=infinity} = FuncState) ->
+ FuncState;
+decrement_count(#trace_func_state_v1{count=1}) ->
+ %% hit the counter limit
+ done;
+decrement_count(#trace_func_state_v1{count=Count} = FuncState) ->
+ FuncState#trace_func_state_v1{count=Count - 1}.
+
+check_timeout(#trace_func_state_v1{timeout=infinity} = FuncState) ->
+ FuncState;
+check_timeout(#trace_func_state_v1{timeout=Timeout, started=Started} = FuncState) ->
+ case (timer:now_diff(os:timestamp(), Started) / 1000) > Timeout of
+ true ->
+ done;
+ false ->
+ FuncState
+ end.
+
+-ifdef(TEST).
+get_sink_handler_status_ascii_test() ->
+ File = "C:\\ProgramData\\Directory With Spaces\\lager.log",
+ validate_status(File).
+
+get_sink_handler_status_latin_test() ->
+ File = "C:\\ProgramData\\Tést Directory\\lager.log",
+ validate_status(File).
+
+get_sink_handler_status_unicode_test() ->
+ File = "C:\\ProgramData\\찦차를 타고 온 펲시맨과 쑛다리 똠방각하 (Korean)\\lager.log",
+ validate_status(File).
+
+validate_status(File) ->
+ Handler = {lager_file_backend, File},
+ Status = get_sink_handler_status(?DEFAULT_SINK, Handler, debug),
+ ?assertNotEqual(nomatch, string:find(Status, File)).
+-endif.

guam-0.9.11.tar.gz/_checkouts/lager/src/lager_app.erl Added

@@ -0,0 +1,426 @@
+%% Copyright (c) 2011-2012 Basho Technologies, Inc. All Rights Reserved.
+%%
+%% This file is provided to you 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.
+
+%% @doc Lager's application module. Not a lot to see here.
+
+%% @private
+
+-module(lager_app).
+
+-behaviour(application).
+-include("lager.hrl").
+-ifdef(TEST).
+-include_lib("eunit/include/eunit.hrl").
+-endif.
+-export([start/0,
+ start/2,
+ start_handler/3,
+ configure_sink/2,
+ stop/1,
+ boot/1]).
+
+%% The `application:get_env/3` compatibility wrapper was useful
+%% for other modules in r15 and before
+-export([get_env/3]).
+
+-define(FILENAMES, '__lager_file_backend_filenames').
+-define(THROTTLE, lager_backend_throttle).
+-define(DEFAULT_HANDLER_CONF,
+ [{lager_console_backend, [{level, info}]},
+ {lager_file_backend,
+ [{file, "error.log"}, {level, error},
+ {size, 10485760}, {date, "$D0"}, {count, 5}]
+ },
+ {lager_file_backend,
+ [{file, "console.log"}, {level, info},
+ {size, 10485760}, {date, "$D0"}, {count, 5}]
+ }
+ ]).
+
+start() ->
+ application:start(lager).
+
+start_throttle(Sink, Threshold, Window) ->
+ _ = supervisor:start_child(lager_handler_watcher_sup,
+ [Sink, ?THROTTLE, [Threshold, Window]]),
+ ok.
+
+determine_async_behavior(_Sink, undefined, _Window) ->
+ ok;
+determine_async_behavior(_Sink, Threshold, _Window) when not is_integer(Threshold) orelse Threshold < 0 ->
+ error_logger:error_msg("Invalid value for 'async_threshold': ~p~n",
+ [Threshold]),
+ throw({error, bad_config});
+determine_async_behavior(Sink, Threshold, undefined) ->
+ start_throttle(Sink, Threshold, erlang:trunc(Threshold * 0.2));
+determine_async_behavior(_Sink, Threshold, Window) when not is_integer(Window) orelse Window > Threshold orelse Window < 0 ->
+ error_logger:error_msg(
+ "Invalid value for 'async_threshold_window': ~p~n", [Window]),
+ throw({error, bad_config});
+determine_async_behavior(Sink, Threshold, Window) ->
+ start_throttle(Sink, Threshold, Window).
+
+start_handlers(_Sink, undefined) ->
+ ok;
+start_handlers(_Sink, Handlers) when not is_list(Handlers) ->
+ error_logger:error_msg(
+ "Invalid value for 'handlers' (must be list): ~p~n", [Handlers]),
+ throw({error, bad_config});
+start_handlers(Sink, Handlers) ->
+ %% handlers failing to start are handled in the handler_watcher
+ lager_config:global_set(handlers,
+ lager_config:global_get(handlers, []) ++
+ lists:map(fun({Module, Config}) ->
+ check_handler_config(Module, Config),
+ start_handler(Sink, Module, Config);
+ (_) ->
+ throw({error, bad_config})
+ end,
+ expand_handlers(Handlers))),
+ ok.
+
+start_handler(Sink, Module, Config) ->
+ {ok, Watcher} = supervisor:start_child(lager_handler_watcher_sup,
+ [Sink, Module, Config]),
+ {Module, Watcher, Sink}.
+
+check_handler_config({lager_file_backend, F}, Config) when is_list(Config); is_tuple(Config) ->
+ Fs = case get(?FILENAMES) of
+ undefined -> ordsets:new();
+ X -> X
+ end,
+ case ordsets:is_element(F, Fs) of
+ true ->
+ error_logger:error_msg(
+ "Cannot have same file (~p) in multiple file backends~n", [F]),
+ throw({error, bad_config});
+ false ->
+ put(?FILENAMES,
+ ordsets:add_element(F, Fs))
+ end,
+ ok;
+check_handler_config(_Handler, Config) when is_list(Config) orelse is_atom(Config) ->
+ ok;
+check_handler_config(Handler, _BadConfig) ->
+ throw({error, {bad_config, Handler}}).
+
+clean_up_config_checks() ->
+ erase(?FILENAMES).
+
+interpret_hwm(undefined) ->
+ undefined;
+interpret_hwm(HWM) when not is_integer(HWM) orelse HWM < 0 ->
+ _ = lager:log(warning, self(), "Invalid error_logger high water mark: ~p, disabling", [HWM]),
+ undefined;
+interpret_hwm(HWM) ->
+ HWM.
+
+maybe_install_sink_killer(_Sink, undefined, _ReinstallTimer) -> ok;
+maybe_install_sink_killer(Sink, HWM, undefined) -> maybe_install_sink_killer(Sink, HWM, 5000);
+maybe_install_sink_killer(Sink, HWM, ReinstallTimer) when is_integer(HWM) andalso is_integer(ReinstallTimer)
+ andalso HWM >= 0 andalso ReinstallTimer >= 0 ->
+ _ = supervisor:start_child(lager_handler_watcher_sup, [Sink, lager_manager_killer,
+ [HWM, ReinstallTimer]]);
+maybe_install_sink_killer(_Sink, HWM, ReinstallTimer) ->
+ error_logger:error_msg("Invalid value for 'killer_hwm': ~p or 'killer_reinstall_after': ~p", [HWM, ReinstallTimer]),
+ throw({error, bad_config}).
+
+-spec start_error_logger_handler(boolean(), pos_integer(), list()) -> list().
+start_error_logger_handler(false, _HWM, _Whitelist) ->
+ [];
+start_error_logger_handler(true, HWM, WhiteList) ->
+ GlStrategy = case application:get_env(lager, error_logger_groupleader_strategy) of
+ undefined ->
+ handle;
+ {ok, GlStrategy0} when
+ GlStrategy0 =:= handle;
+ GlStrategy0 =:= ignore;
+ GlStrategy0 =:= mirror ->
+ GlStrategy0;
+ {ok, BadGlStrategy} ->
+ error_logger:error_msg(
+ "Invalid value for 'error_logger_groupleader_strategy': ~p~n",
+ [BadGlStrategy]),
+ throw({error, bad_config})
+ end,
+
+ case whereis(error_logger) of
+ undefined ->
+ %% On OTP 21 and above, error_logger is deprecated in favor of 'logger'
+ %% As a band-aid, boot up error_logger anyway and install it as a logger handler
+ %% we can't use error_logger:add_report_handler because we want supervision of the handler
+ %% so we have to manually add the logger handler
+ %%
+ %% Longer term we should be installing a logger handler instead, but this will bridge the gap
+ %% for now.
+ _ = error_logger:start(),
+ _ = logger:add_handler(error_logger,error_logger,#{level=>info,filter_default=>log}),
+ ok = maybe_remove_logger_handler();
+ _ ->
+ ok
+ end,
+
+ %% capture which handlers we removed from error_logger so we can restore them when lager stops
+ OldHandlers = case supervisor:start_child(lager_handler_watcher_sup, [error_logger, error_logger_lager_h, [HWM, GlStrategy]]) of
+ {ok, _} ->
+ [begin error_logger:delete_report_handler(X), X end ||
+ X <- gen_event:which_handlers(error_logger) -- [error_logger_lager_h | WhiteList]];
+ {error, _} ->
+ []
+ end,
+ OldHandlers.
+
+%% On OTP 21.1 and higher we need to remove the `default' handler.
+%% But it might not exist, so we will wrap this in a try-catch
+%% block
+maybe_remove_logger_handler() ->
+ try
+ ok = logger:remove_handler(default)
+ catch
+ error:undef -> ok;
+ Err:Reason ->
+ error_logger:error_msg("calling logger:remove_handler(default) failed: ~p ~p",
+ [Err, Reason])
+ end.
+
+configure_sink(Sink, SinkDef) ->
+ lager_config:new_sink(Sink),
+ ChildId = lager_util:make_internal_sink_name(Sink),
+ _ = supervisor:start_child(lager_sup,
+ {ChildId,
+ {gen_event, start_link,
+ [{local, Sink}]},
+ permanent, 5000, worker, dynamic}),
+ determine_async_behavior(Sink, proplists:get_value(async_threshold, SinkDef),
+ proplists:get_value(async_threshold_window, SinkDef)
+ ),
+ _ = maybe_install_sink_killer(Sink, proplists:get_value(killer_hwm, SinkDef),
+ proplists:get_value(killer_reinstall_after, SinkDef)),
+ start_handlers(Sink,
+ proplists:get_value(handlers, SinkDef, [])),
+
+ lager:update_loglevel_config(Sink).
+
+
+configure_extra_sinks(Sinks) ->
+ lists:foreach(fun({Sink, Proplist}) -> configure_sink(Sink, Proplist) end,
+ Sinks).
+
+-spec get_env(atom(), atom(), term()) -> term().
+get_env(Application, Key, Default) ->
+ application:get_env(Application, Key, Default).
+
+start(_StartType, _StartArgs) ->
+ {ok, Pid} = lager_sup:start_link(),
+ SavedHandlers = boot(),
+ _ = boot('__all_extra'),
+ _ = boot('__traces'),
+ clean_up_config_checks(),
+ {ok, Pid, SavedHandlers}.
+
+boot() ->
+ %% Handle the default sink.
+ determine_async_behavior(?DEFAULT_SINK,
+ application:get_env(lager, async_threshold, undefined),
+ application:get_env(lager, async_threshold_window, undefined)),
+
+ _ = maybe_install_sink_killer(?DEFAULT_SINK, application:get_env(lager, killer_hwm, undefined),
+ application:get_env(lager, killer_reinstall_after, undefined)),
+
+ start_handlers(?DEFAULT_SINK,
+ application:get_env(lager, handlers, ?DEFAULT_HANDLER_CONF)),
+
+ lager:update_loglevel_config(?DEFAULT_SINK),
+
+ SavedHandlers = start_error_logger_handler(
+ application:get_env(lager, error_logger_redirect, true),
+ interpret_hwm(application:get_env(lager, error_logger_hwm, 0)),
+ application:get_env(lager, error_logger_whitelist, [])
+ ),
+
+ SavedHandlers.
+
+boot('__traces') ->
+ _ = lager_util:trace_filter(none),
+ ok = add_configured_traces();
+
+boot('__all_extra') ->
+ configure_extra_sinks(application:get_env(lager, extra_sinks, []));
+
+boot(?DEFAULT_SINK) -> boot();
+boot(Sink) ->
+ AllSinksDef = application:get_env(lager, extra_sinks, []),
+ boot_sink(Sink, lists:keyfind(Sink, 1, AllSinksDef)).
+
+boot_sink(Sink, {Sink, Def}) ->
+ configure_sink(Sink, Def);
+boot_sink(Sink, false) ->
+ configure_sink(Sink, []).
+
+stop(Handlers) ->
+ lists:foreach(fun(Handler) ->
+ error_logger:add_report_handler(Handler)
+ end, Handlers),
+ lager_config:cleanup().
+
+expand_handlers([]) ->
+ [];
+expand_handlers([{lager_file_backend, [{Key, _Value}|_]=Config}|T]) when is_atom(Key) ->
+ %% this is definitely a new-style config, no expansion needed
+ [maybe_make_handler_id(lager_file_backend, Config) | expand_handlers(T)];
+expand_handlers([{lager_file_backend, Configs}|T]) ->
+ ?INT_LOG(notice, "Deprecated lager_file_backend config detected, please consider updating it", []),
+ [ {lager_file_backend:config_to_id(Config), Config} || Config <- Configs] ++
+ expand_handlers(T);
+expand_handlers([{Mod, Config}|T]) when is_atom(Mod) ->
+ [maybe_make_handler_id(Mod, Config) | expand_handlers(T)];
+expand_handlers([H|T]) ->
+ [H | expand_handlers(T)].
+
+add_configured_traces() ->
+ Traces = case application:get_env(lager, traces) of
+ undefined ->
+ [];
+ {ok, TraceVal} ->
+ TraceVal
+ end,
+
+ lists:foreach(fun start_configured_trace/1, Traces),
+ ok.
+
+start_configured_trace({Handler, Filter}) ->
+ {ok, _} = lager:trace(Handler, Filter);
+start_configured_trace({Handler, Filter, Level}) when is_atom(Level) ->
+ {ok, _} = lager:trace(Handler, Filter, Level).
+
+maybe_make_handler_id(Mod, Config) ->
+ %% Allow the backend to generate a gen_event handler id, if it wants to.
+ %% We don't use erlang:function_exported here because that requires the module
+ %% already be loaded, which is unlikely at this phase of startup. Using code:load
+ %% caused undesirable side-effects with generating code-coverage reports.
+ try Mod:config_to_id(Config) of
+ Id ->
+ {Id, Config}
+ catch
+ error:undef ->
+ {Mod, Config}
+ end.
+
+-ifdef(TEST).
+application_config_mangling_test_() ->
+ [
+ {"Explode the file backend handlers",
+ ?_assertMatch(
+ [{lager_console_backend, [{level, info}]},
+ {{lager_file_backend,"error.log"},{"error.log",error,10485760, "$D0",5}},
+ {{lager_file_backend,"console.log"},{"console.log",info,10485760, "$D0",5}}
+ ],
+ expand_handlers([{lager_console_backend, [{level, info}]},
+ {lager_file_backend, [
+ {"error.log", error, 10485760, "$D0", 5},
+ {"console.log", info, 10485760, "$D0", 5}
+ ]}]
+ ))
+ },
+ {"Explode the short form of backend file handlers",
+ ?_assertMatch(
+ [{lager_console_backend, [{level, info}]},
+ {{lager_file_backend,"error.log"},{"error.log",error}},
+ {{lager_file_backend,"console.log"},{"console.log",info}}
+ ],
+ expand_handlers([{lager_console_backend, [{level, info}]},
+ {lager_file_backend, [
+ {"error.log", error},
+ {"console.log", info}
+ ]}]
+ ))
+ },
+ {"Explode with formatter info",
+ ?_assertMatch(
+ [{{lager_file_backend,"test.log"}, [{"test.log", debug, 10485760, "$D0", 5},{lager_default_formatter,["[",severity,"] ", message, "\n"]}]},
+ {{lager_file_backend,"test2.log"}, [{"test2.log",debug, 10485760, "$D0", 5},{lager_default_formatter,["2>[",severity,"] ", message, "\n"]}]}],
+ expand_handlers([{lager_file_backend, [
+ [{"test.log", debug, 10485760, "$D0", 5},{lager_default_formatter,["[",severity,"] ", message, "\n"]}],
+ [{"test2.log",debug, 10485760, "$D0", 5},{lager_default_formatter,["2>[",severity,"] ",message, "\n"]}]
+ ]
+ }])
+ )
+ },
+ {"Explode short form with short formatter info",
+ ?_assertMatch(
+ [{{lager_file_backend,"test.log"}, [{"test.log", debug},{lager_default_formatter,["[",severity,"] ", message, "\n"]}]},
+ {{lager_file_backend,"test2.log"}, [{"test2.log",debug},{lager_default_formatter}]}],
+ expand_handlers([{lager_file_backend, [
+ [{"test.log", debug},{lager_default_formatter,["[",severity,"] ", message, "\n"]}],
+ [{"test2.log",debug},{lager_default_formatter}]
+ ]
+ }])
+ )
+ },
+ {"New form needs no expansion",
+ ?_assertMatch([
+ {{lager_file_backend,"test.log"}, [{file, "test.log"}]},
+ {{lager_file_backend,"test2.log"}, [{file, "test2.log"}, {level, info}, {sync_on, none}]},
+ {{lager_file_backend,"test3.log"}, [{formatter, lager_default_formatter}, {file, "test3.log"}]}
+ ],
+ expand_handlers([
+ {lager_file_backend, [{file, "test.log"}]},
+ {lager_file_backend, [{file, "test2.log"}, {level, info}, {sync_on, none}]},
+ {lager_file_backend, [{formatter, lager_default_formatter},{file, "test3.log"}]}
+ ])
+ )
+ }
+ ].
+
+check_handler_config_test_() ->
+ Good = expand_handlers(?DEFAULT_HANDLER_CONF),
+ Bad = expand_handlers([{lager_console_backend, [{level, info}]},
+ {lager_file_backend, [{file, "same_file.log"}]},
+ {lager_file_backend, [{file, "same_file.log"}, {level, info}]}]),
+ AlsoBad = [{lager_logstash_backend,
+ {level, info},
+ {output, {udp, "localhost", 5000}},
+ {format, json},
+ {json_encoder, jiffy}}],
+ BadToo = [{fail, {fail}}],
+ OldSchoolLagerGood = expand_handlers([{lager_console_backend, [{level, info}]},
+ {lager_file_backend, [
+ {"./log/error.log",error,10485760,"$D0",5},
+ {"./log/console.log",info,10485760,"$D0",5},
+ {"./log/debug.log",debug,10485760,"$D0",5}
+ ]}]),
+ NewConfigMissingList = expand_handlers([{foo_backend, {file, "same_file.log"}}]),
+ [
+ {"lager_file_backend_good",
+ ?_assertEqual([ok, ok, ok], [ check_handler_config(M,C) || {M,C} <- Good ])
+ },
+ {"lager_file_backend_bad",
+ ?_assertThrow({error, bad_config}, [ check_handler_config(M,C) || {M,C} <- Bad ])
+ },
+ {"Invalid config dies",
+ ?_assertThrow({error, bad_config}, start_handlers(foo, AlsoBad))
+ },
+ {"Invalid config dies",
+ ?_assertThrow({error, {bad_config, _}}, start_handlers(foo, BadToo))
+ },
+ {"Old Lager config works",
+ ?_assertEqual([ok, ok, ok, ok], [ check_handler_config(M, C) || {M, C} <- OldSchoolLagerGood])
+ },
+ {"New Config missing its list should fail",
+ ?_assertThrow({error, {bad_config, foo_backend}}, [ check_handler_config(M, C) || {M, C} <- NewConfigMissingList])
+ }
+ ].
+-endif.

guam-0.9.11.tar.gz/_checkouts/lager/src/lager_backend_throttle.erl Added

@@ -0,0 +1,105 @@
+%% Copyright (c) 2011-2013 Basho Technologies, Inc. All Rights Reserved.
+%%
+%% This file is provided to you 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.
+
+%% @doc A simple gen_event backend used to monitor mailbox size and
+%% switch log messages between synchronous and asynchronous modes.
+%% A gen_event handler is used because a process getting its own mailbox
+%% size doesn't involve getting a lock, and gen_event handlers run in their
+%% parent's process.
+
+-module(lager_backend_throttle).
+
+-include("lager.hrl").
+
+-behaviour(gen_event).
+
+-export([init/1, handle_call/2, handle_event/2, handle_info/2, terminate/2,
+ code_change/3]).
+
+%%
+%% Allow test code to verify that we're doing the needful.
+-ifdef(TEST).
+-define(ETS_TABLE, async_threshold_test).
+-define(TOGGLE_SYNC(), test_increment(sync_toggled)).
+-define(TOGGLE_ASYNC(), test_increment(async_toggled)).
+-else.
+-define(TOGGLE_SYNC(), true).
+-define(TOGGLE_ASYNC(), true).
+-endif.
+
+-record(state, {
+ sink :: atom(),
+ hwm :: non_neg_integer(),
+ window_min :: non_neg_integer(),
+ async = true :: boolean()
+ }).
+
+init([{sink, Sink}, Hwm, Window]) ->
+ lager_config:set({Sink, async}, true),
+ {ok, #state{sink=Sink, hwm=Hwm, window_min=Hwm - Window}}.
+
+
+handle_call(get_loglevel, State) ->
+ {ok, {mask, ?LOG_NONE}, State};
+handle_call({set_loglevel, _Level}, State) ->
+ {ok, ok, State};
+handle_call(_Request, State) ->
+ {ok, ok, State}.
+
+handle_event({log, _Message},State) ->
+ {message_queue_len, Len} = erlang:process_info(self(), message_queue_len),
+ case {Len > State#state.hwm, Len < State#state.window_min, State#state.async} of
+ {true, _, true} ->
+ %% need to flip to sync mode
+ ?TOGGLE_SYNC(),
+ lager_config:set({State#state.sink, async}, false),
+ {ok, State#state{async=false}};
+ {_, true, false} ->
+ %% need to flip to async mode
+ ?TOGGLE_ASYNC(),
+ lager_config:set({State#state.sink, async}, true),
+ {ok, State#state{async=true}};
+ _ ->
+ %% nothing needs to change
+ {ok, State}
+ end;
+handle_event(_Event, State) ->
+ {ok, State}.
+
+handle_info(_Info, State) ->
+ {ok, State}.
+
+%% @private
+terminate(_Reason, _State) ->
+ ok.
+
+%% @private
+code_change(_OldVsn, State, _Extra) ->
+ {ok, State}.
+
+-ifdef(TEST).
+test_get(Key) ->
+ get_default(ets:lookup(?ETS_TABLE, Key)).
+
+test_increment(Key) ->
+ ets:insert(?ETS_TABLE,
+ {Key, test_get(Key) + 1}).
+
+get_default([]) ->
+ 0;
+get_default([{_Key, Value}]) ->
+ Value.
+-endif.

guam-0.9.11.tar.gz/_checkouts/lager/src/lager_common_test_backend.erl Added

@@ -0,0 +1,121 @@
+-module(lager_common_test_backend).
+
+-behavior(gen_event).
+
+%% gen_event callbacks
+-export([init/1,
+         handle_call/2,
+         handle_event/2,
+         handle_info/2,
+         terminate/2,
+         code_change/3]).
+-export([get_logs/0,
+        bounce/0,
+        bounce/1]).
+
+%% holds the log messages for retreival on terminate
+-record(state, {level :: {mask, integer()},
+                formatter :: atom(),
+                format_config :: any(),
+                log = [] :: list()}).
+
+-include("lager.hrl").
+-define(TERSE_FORMAT,[time, " ", color, "[", severity,"] ", message]).
+
+%% @doc Before every test, just
+%% lager_common_test_backend:bounce(Level) with the log level of your
+%% choice. Every message will be passed along to ct:pal for your
+%% viewing in the common_test reports. Also, you can call
+%% lager_common_test_backend:get_logs/0 to get a list of all log
+%% messages this backend has received during your test. You can then
+%% search that list for expected log messages.
+
+
+-spec get_logs() -> [iolist()] | {error, term()}.
+get_logs() ->
+    gen_event:call(lager_event, ?MODULE, get_logs, infinity).
+
+bounce() ->
+    bounce(error).
+
+bounce(Level) ->
+    _ = application:stop(lager),
+    application:set_env(lager, suppress_application_start_stop, true),
+    application:set_env(lager, handlers,
+                        [
+                         {lager_common_test_backend, [Level, false]}
+                        ]),
+    ok = lager:start(),
+    %% we care more about getting all of our messages here than being
+    %% careful with the amount of memory that we're using.
+    error_logger_lager_h:set_high_water(100000),
+    ok.
+
+-spec(init(integer()|atom()|[term()]) -> {ok, #state{}} | {error, atom()}).
+%% @private
+%% @doc Initializes the event handler
+init([Level, true]) -> % for backwards compatibility
+    init([Level,{lager_default_formatter,[{eol, "\n"}]}]);
+init([Level,false]) -> % for backwards compatibility
+    init([Level,{lager_default_formatter,?TERSE_FORMAT ++ ["\n"]}]);
+init([Level,{Formatter,FormatterConfig}]) when is_atom(Formatter) ->
+    case lists:member(Level, ?LEVELS) of
+        true ->
+            {ok, #state{level=lager_util:config_to_mask(Level),
+                    formatter=Formatter,
+                    format_config=FormatterConfig}};
+        _ ->
+            {error, bad_log_level}
+    end;
+init(Level) ->
+    init([Level,{lager_default_formatter,?TERSE_FORMAT ++ ["\n"]}]).
+
+-spec(handle_event(tuple(), #state{}) -> {ok, #state{}}).
+%% @private
+handle_event({log, Message},
+    #state{level=L,formatter=Formatter,format_config=FormatConfig,log=Logs} = State) ->
+    case lager_util:is_loggable(Message,L,?MODULE) of
+        true ->
+            Log = Formatter:format(Message,FormatConfig),
+            ct:pal(Log),
+            {ok, State#state{log=[Log|Logs]}};
+        false ->
+            {ok, State}
+    end;
+handle_event(Event, State) ->
+    ct:pal(Event),
+    {ok, State#state{log = [Event|State#state.log]}}.
+
+-spec(handle_call(any(), #state{}) -> {ok, any(), #state{}}).
+%% @private
+%% @doc gets and sets loglevel. This is part of the lager backend api.
+handle_call(get_loglevel, #state{level=Level} = State) ->
+    {ok, Level, State};
+handle_call({set_loglevel, Level}, State) ->
+    case lists:member(Level, ?LEVELS) of
+        true ->
+            {ok, ok, State#state{level=lager_util:config_to_mask(Level)}};
+        _ ->
+            {ok, {error, bad_log_level}, State}
+    end;
+handle_call(get_logs, #state{log = Logs} = State) ->
+    {ok, lists:reverse(Logs), State};
+handle_call(_, State) ->
+    {ok, ok, State}.
+
+-spec(handle_info(any(), #state{}) -> {ok, #state{}}).
+%% @private
+%% @doc gen_event callback, does nothing.
+handle_info(_, State) ->
+    {ok, State}.
+
+-spec(code_change(any(), #state{}, any()) -> {ok, #state{}}).
+%% @private
+%% @doc gen_event callback, does nothing.
+code_change(_OldVsn, State, _Extra) ->
+    {ok, State}.
+
+-spec(terminate(any(), #state{}) -> {ok, list()}).
+%% @doc gen_event callback, does nothing.
+terminate(_Reason, #state{log=Logs}) ->
+    {ok, lists:reverse(Logs)}.

guam-0.9.11.tar.gz/_checkouts/lager/src/lager_config.erl Added

@@ -0,0 +1,136 @@
+%% Copyright (c) 2011-2012 Basho Technologies, Inc. All Rights Reserved.
+%%
+%% This file is provided to you 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.
+
+%% @doc Helper functions for working with lager's runtime config
+
+-module(lager_config).
+
+-include("lager.hrl").
+
+-export([new/0, new_sink/1, get/1, get/2, set/2,
+ global_get/1, global_get/2, global_set/2, cleanup/0]).
+
+-define(TBL, lager_config).
+-define(GLOBAL, '_global').
+
+%% For multiple sinks, the key is now the registered event name and the old key
+%% as a tuple.
+%%
+%% {{lager_event, loglevel}, Value} instead of {loglevel, Value}
+
+new() ->
+ init(),
+ new_sink(?DEFAULT_SINK),
+ %% Need to be able to find the `lager_handler_watcher' for all handlers
+ insert_new({?GLOBAL, handlers}, []),
+ ok.
+
+new_sink(Sink) ->
+ %% use insert_new here so that if we're in an appup we don't mess anything up
+ %%
+ %% until lager is completely started, allow all messages to go through
+ insert_new({Sink, loglevel}, {element(2, lager_util:config_to_mask(debug)), []}).
+
+global_get(Key) ->
+ global_get(Key, undefined).
+
+global_get(Key, Default) ->
+ get({?GLOBAL, Key}, Default).
+
+global_set(Key, Value) ->
+ set({?GLOBAL, Key}, Value).
+
+
+get({_Sink, _Key}=FullKey) ->
+ get(FullKey, undefined);
+get(Key) ->
+ get({?DEFAULT_SINK, Key}, undefined).
+
+get({Sink, Key}, Default) ->
+ lookup({Sink, Key}, Default);
+get(Key, Default) ->
+ get({?DEFAULT_SINK, Key}, Default).
+
+set({Sink, Key}, Value) ->
+ insert({Sink, Key}, Value);
+set(Key, Value) ->
+ set({?DEFAULT_SINK, Key}, Value).
+
+%% check if we can use persistent_term for config
+%% persistent term was added in OTP 21.2 but we can't
+%% check minor versions with macros so we're stuck waiting
+%% for OTP 22
+-ifdef(HAVE_PERSISTENT_TERM).
+init() ->
+ ok.
+
+insert(Key, Value) ->
+ persistent_term:put({?TBL, Key}, Value).
+
+insert_new(Key, Value) ->
+ try persistent_term:get({?TBL, Key}) of
+ _Value ->
+ false
+ catch error:badarg ->
+ insert(Key, Value),
+ true
+ end.
+
+lookup(Key, Default) ->
+ try persistent_term:get({?TBL, Key}) of
+ Value -> Value
+ catch
+ error:badarg ->
+ Default
+ end.
+
+cleanup() ->
+ [ persistent_term:erase(K) || {{?TBL, _} = K, _} <- persistent_term:get() ].
+
+-else.
+
+init() ->
+ %% set up the ETS configuration table
+ _ = try ets:new(?TBL, [named_table, public, set, {keypos, 1}, {read_concurrency, true}]) of
+ _Result ->
+ ok
+ catch
+ error:badarg ->
+ ?INT_LOG(warning, "Table ~p already exists", [?TBL])
+ end.
+
+insert(Key, Value) ->
+ ets:insert(?TBL, {Key, Value}).
+
+insert_new(Key, Value) ->
+ ets:insert_new(?TBL, {Key, Value}).
+
+lookup(Key, Default) ->
+ try
+ case ets:lookup(?TBL, Key) of
+ [] ->
+ Default;
+ [{Key, Res}] ->
+ Res
+ end
+ catch
+ _:_ ->
+ Default
+ end.
+
+cleanup() -> ok.
+-endif.
+

guam-0.9.11.tar.gz/_checkouts/lager/src/lager_console_backend.erl Added

@@ -0,0 +1,604 @@
+%% Copyright (c) 2011-2012, 2014 Basho Technologies, Inc. All Rights Reserved.
+%%
+%% This file is provided to you 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.
+
+%% @doc Console backend for lager.
+%% Configuration is a proplist with the following keys:
+%% <ul>
+%% <li>`level' - log level to use</li>
+%% <li>`use_stderr' - either `true' or `false', defaults to false. If set to true,
+%% use standard error to output console log messages</li>
+%% <li>`formatter' - the module to use when formatting log messages. Defaults to
+%% `lager_default_formatter'</li>
+%% <li>`formatter_config' - the format configuration string. Defaults to
+%% `time [ severity ] message'</li>
+%% </ul>
+
+-module(lager_console_backend).
+
+-behaviour(gen_event).
+
+-export([init/1, handle_call/2, handle_event/2, handle_info/2, terminate/2,
+ code_change/3]).
+
+-record(state, {level :: {'mask', integer()},
+ out = user :: user | standard_error | pid(),
+ id :: atom() | {atom(), any()},
+ formatter :: atom(),
+ format_config :: any(),
+ colors=[] :: list()}).
+
+-ifdef(TEST).
+-include_lib("eunit/include/eunit.hrl").
+-compile([{parse_transform, lager_transform}]).
+-endif.
+
+
+-include("lager.hrl").
+
+-define(TERSE_FORMAT,[time, " ", color, "[", severity,"] ", message]).
+-define(DEFAULT_FORMAT_CONFIG, ?TERSE_FORMAT ++ [eol()]).
+-define(FORMAT_CONFIG_OFF, [{eol, eol()}]).
+
+-ifdef(TEST).
+-define(DEPRECATED(_Msg), ok).
+-else.
+-define(DEPRECATED(Msg),
+ io:format(user, "WARNING: This is a deprecated console configuration. Please use \"~w\" instead.~n", [Msg])).
+-endif.
+
+%% @private
+init([Level]) when is_atom(Level) ->
+ ?DEPRECATED([{level, Level}]),
+ init([{level, Level}]);
+init([Level, true]) when is_atom(Level) -> % for backwards compatibility
+ ?DEPRECATED([{level, Level}, {formatter_config, [{eol, "\\r\\n\\"}]}]),
+ init([{level, Level}, {formatter_config, ?FORMAT_CONFIG_OFF}]);
+init([Level, false]) when is_atom(Level) -> % for backwards compatibility
+ ?DEPRECATED([{level, Level}]),
+ init([{level, Level}]);
+
+init(Options) when is_list(Options) ->
+ true = validate_options(Options),
+ Colors = case application:get_env(lager, colored) of
+ {ok, true} ->
+ {ok, LagerColors} = application:get_env(lager, colors),
+ LagerColors;
+ _ -> []
+ end,
+
+ Level = get_option(level, Options, undefined),
+ try {is_new_style_console_available(), lager_util:config_to_mask(Level)} of
+ {false, _} ->
+ Msg = "Lager's console backend is incompatible with the 'old' shell, not enabling it",
+ %% be as noisy as possible, log to every possible place
+ try
+ alarm_handler:set_alarm({?MODULE, "WARNING: " ++ Msg})
+ catch
+ _:_ ->
+ error_logger:warning_msg(Msg ++ "~n")
+ end,
+ io:format("WARNING: " ++ Msg ++ "~n"),
+ ?INT_LOG(warning, Msg, []),
+ {error, {fatal, old_shell}};
+ {true, L} ->
+ [UseErr, GroupLeader, ID, Formatter, Config] = [ get_option(K, Options, Default) || {K, Default} <- [
+ {use_stderr, false},
+ {group_leader, false},
+ {id, ?MODULE},
+ {formatter, lager_default_formatter},
+ {formatter_config, ?DEFAULT_FORMAT_CONFIG}
+ ]
+ ],
+ Out = case UseErr of
+ false ->
+ case GroupLeader of
+ false -> user;
+ GLPid when is_pid(GLPid) ->
+ erlang:monitor(process, GLPid),
+ GLPid
+ end;
+ true -> standard_error
+ end,
+ {ok, #state{level=L,
+ id=ID,
+ out=Out,
+ formatter=Formatter,
+ format_config=Config,
+ colors=Colors}}
+ catch
+ _:_ ->
+ {error, {fatal, bad_log_level}}
+ end;
+init(Level) when is_atom(Level) ->
+ ?DEPRECATED([{level, Level}]),
+ init([{level, Level}]);
+init(Other) ->
+ {error, {fatal, {bad_console_config, Other}}}.
+
+validate_options([]) -> true;
+validate_options([{level, L}|T]) when is_atom(L) ->
+ case lists:member(L, ?LEVELS) of
+ false ->
+ throw({error, {fatal, {bad_level, L}}});
+ true ->
+ validate_options(T)
+ end;
+validate_options([{use_stderr, true}|T]) ->
+ validate_options(T);
+validate_options([{use_stderr, false}|T]) ->
+ validate_options(T);
+validate_options([{formatter, M}|T]) when is_atom(M) ->
+ validate_options(T);
+validate_options([{formatter_config, C}|T]) when is_list(C) ->
+ validate_options(T);
+validate_options([{group_leader, L}|T]) when is_pid(L) ->
+ validate_options(T);
+validate_options([{id, {?MODULE, _}}|T]) ->
+ validate_options(T);
+validate_options([H|_]) ->
+ throw({error, {fatal, {bad_console_config, H}}}).
+
+get_option(K, Options, Default) ->
+ case lists:keyfind(K, 1, Options) of
+ {K, V} -> V;
+ false -> Default
+ end.
+
+%% @private
+handle_call(get_loglevel, #state{level=Level} = State) ->
+ {ok, Level, State};
+handle_call({set_loglevel, Level}, State) ->
+ try lager_util:config_to_mask(Level) of
+ Levels ->
+ {ok, ok, State#state{level=Levels}}
+ catch
+ _:_ ->
+ {ok, {error, bad_log_level}, State}
+ end;
+handle_call(_Request, State) ->
+ {ok, ok, State}.
+
+%% @private
+handle_event({log, Message},
+ #state{level=L,out=Out,formatter=Formatter,format_config=FormatConfig,colors=Colors,id=ID} = State) ->
+ case lager_util:is_loggable(Message, L, ID) of
+ true ->
+ io:put_chars(Out, Formatter:format(Message,FormatConfig,Colors)),
+ {ok, State};
+ false ->
+ {ok, State}
+ end;
+handle_event(_Event, State) ->
+ {ok, State}.
+
+%% @private
+handle_info({'DOWN', _, process, Out, _}, #state{out=Out}) ->
+ remove_handler;
+handle_info(_Info, State) ->
+ {ok, State}.
+
+%% @private
+terminate(remove_handler, _State=#state{id=ID}) ->
+ %% have to do this asynchronously because we're in the event handlr
+ spawn(fun() -> lager:clear_trace_by_destination(ID) end),
+ ok;
+terminate(_Reason, _State) ->
+ ok.
+
+%% @private
+code_change(_OldVsn, State, _Extra) ->
+ {ok, State}.
+
+eol() ->
+ case application:get_env(lager, colored) of
+ {ok, true} ->
+ "\e[0m\r\n";
+ _ ->
+ "\r\n"
+ end.
+
+-ifdef(TEST).
+is_new_style_console_available() ->
+ true.
+-else.
+is_new_style_console_available() ->
+ %% Criteria:
+ %% 1. If the user has specified '-noshell' on the command line,
+ %% then we will pretend that the new-style console is available.
+ %% If there is no shell at all, then we don't have to worry
+ %% about log events being blocked by the old-style shell.
+ %% 2. Windows doesn't support the new shell, so all windows users
+ %% have is the oldshell.
+ %% 3. If the user_drv process is registered, all is OK.
+ %% 'user_drv' is a registered proc name used by the "new"
+ %% console driver.
+ init:get_argument(noshell) /= error orelse
+ element(1, os:type()) /= win32 orelse
+ is_pid(whereis(user_drv)).
+-endif.
+
+-ifdef(TEST).
+console_config_validation_test_() ->
+ Good = [{level, info}, {use_stderr, true}],
+ Bad1 = [{level, foo}, {use_stderr, flase}],
+ Bad2 = [{level, info}, {use_stderr, flase}],
+ AllGood = [{level, info}, {formatter, my_formatter},
+ {formatter_config, ["blort", "garbage"]},
+ {use_stderr, false}],
+ [
+ ?_assertEqual(true, validate_options(Good)),
+ ?_assertThrow({error, {fatal, {bad_level, foo}}}, validate_options(Bad1)),
+ ?_assertThrow({error, {fatal, {bad_console_config, {use_stderr, flase}}}}, validate_options(Bad2)),
+ ?_assertEqual(true, validate_options(AllGood))
+ ].
+
+console_log_test_() ->
+ %% tiny recursive fun that pretends to be a group leader
+ F = fun(Self) ->
+ fun() ->
+ YComb = fun(Fun) ->
+ receive
+ {io_request, From, ReplyAs, {put_chars, unicode, _Msg}} = Y ->
+ From ! {io_reply, ReplyAs, ok},
+ Self ! Y,
+ Fun(Fun);
+ Other ->
+ ?debugFmt("unexpected message ~p~n", [Other]),
+ Self ! Other
+ end
+ end,
+ YComb(YComb)
+ end
+ end,
+ {foreach,
+ fun() ->
+ error_logger:tty(false),
+ application:load(lager),
+ application:set_env(lager, handlers, []),
+ application:set_env(lager, error_logger_redirect, false),
+ lager:start(),
+ whereis(user)
+ end,
+ fun(User) ->
+ unregister(user),
+ register(user, User),
+ application:stop(lager),
+ application:stop(goldrush),
+ error_logger:tty(true)
+ end,
+ [
+ {"regular console logging",
+ fun() ->
+ Pid = spawn(F(self())),
+ unregister(user),
+ register(user, Pid),
+ erlang:group_leader(Pid, whereis(lager_event)),
+ gen_event:add_handler(lager_event, lager_console_backend, [{level, info}]),
+ lager_config:set({lager_event, loglevel}, {element(2, lager_util:config_to_mask(info)), []}),
+ lager:log(info, self(), "Test message"),
+ receive
+ {io_request, From, ReplyAs, {put_chars, unicode, Msg}} ->
+ From ! {io_reply, ReplyAs, ok},
+ TestMsg = "Test message" ++ eol(),
+ ?assertMatch([_, "[info]", TestMsg], re:split(Msg, " ", [{return, list}, {parts, 3}]))
+ after
+ 500 ->
+ ?assert(false)
+ end
+ end
+ },
+ {"verbose console logging",
+ fun() ->
+ Pid = spawn(F(self())),
+ unregister(user),
+ register(user, Pid),
+ erlang:group_leader(Pid, whereis(lager_event)),
+ gen_event:add_handler(lager_event, lager_console_backend, [info, true]),
+ lager_config:set({lager_event, loglevel}, {element(2, lager_util:config_to_mask(info)), []}),
+ lager:info("Test message"),
+ PidStr = pid_to_list(self()),
+ receive
+ {io_request, _, _, {put_chars, unicode, Msg}} ->
+ TestMsg = "Test message" ++ eol(),
+ ?assertMatch([_, _, "[info]", PidStr, _, TestMsg], re:split(Msg, "[ @]", [{return, list}, {parts, 6}]))
+ after
+ 500 ->
+ ?assert(false)
+ end
+ end
+ },
+ {"custom format console logging",
+ fun() ->
+ Pid = spawn(F(self())),
+ unregister(user),
+ register(user, Pid),
+ erlang:group_leader(Pid, whereis(lager_event)),
+ gen_event:add_handler(lager_event, lager_console_backend,
+ [{level, info}, {formatter, lager_default_formatter}, {formatter_config, [date,"#",time,"#",severity,"#",node,"#",pid,"#",
+ module,"#",function,"#",file,"#",line,"#",message,"\r\n"]}]),
+ lager_config:set({lager_event, loglevel}, {?INFO, []}),
+ lager:info("Test message"),
+ PidStr = pid_to_list(self()),
+ NodeStr = atom_to_list(node()),
+ ModuleStr = atom_to_list(?MODULE),
+ receive
+ {io_request, _, _, {put_chars, unicode, Msg}} ->
+ TestMsg = "Test message" ++ eol(),
+ ?assertMatch([_, _, "info", NodeStr, PidStr, ModuleStr, _, _, _, TestMsg],
+ re:split(Msg, "#", [{return, list}, {parts, 10}]))
+ after
+ 500 ->
+ ?assert(false)
+ end
+ end
+ },
+ {"tracing should work",
+ fun() ->
+ Pid = spawn(F(self())),
+ unregister(user),
+ register(user, Pid),
+ gen_event:add_handler(lager_event, lager_console_backend, [{level, info}]),
+ erlang:group_leader(Pid, whereis(lager_event)),
+ lager_config:set({lager_event, loglevel}, {element(2, lager_util:config_to_mask(info)), []}),
+ lager:debug("Test message"),
+ receive
+ {io_request, From, ReplyAs, {put_chars, unicode, _Msg}} ->
+ From ! {io_reply, ReplyAs, ok},
+ ?assert(false)
+ after
+ 500 ->
+ ?assert(true)
+ end,
+ {ok, _} = lager:trace_console([{module, ?MODULE}]),
+ lager:debug("Test message"),
+ receive
+ {io_request, From1, ReplyAs1, {put_chars, unicode, Msg1}} ->
+ From1 ! {io_reply, ReplyAs1, ok},
+ TestMsg = "Test message" ++ eol(),
+ ?assertMatch([_, "[debug]", TestMsg], re:split(Msg1, " ", [{return, list}, {parts, 3}]))
+ after
+ 500 ->
+ ?assert(false)
+ end
+ end
+ },
+ {"tracing doesn't duplicate messages",
+ fun() ->
+ Pid = spawn(F(self())),
+ unregister(user),
+ register(user, Pid),
+ gen_event:add_handler(lager_event, lager_console_backend, [{level, info}]),
+ lager_config:set({lager_event, loglevel}, {element(2, lager_util:config_to_mask(info)), []}),
+ erlang:group_leader(Pid, whereis(lager_event)),
+ lager:debug("Test message"),
+ receive
+ {io_request, From, ReplyAs, {put_chars, unicode, _Msg}} ->
+ From ! {io_reply, ReplyAs, ok},
+ ?assert(false)
+ after
+ 500 ->
+ ?assert(true)
+ end,
+ {ok, _} = lager:trace_console([{module, ?MODULE}]),
+ lager:error("Test message"),
+ receive
+ {io_request, From1, ReplyAs1, {put_chars, unicode, Msg1}} ->
+ From1 ! {io_reply, ReplyAs1, ok},
+ TestMsg = "Test message" ++ eol(),
+ ?assertMatch([_, "[error]", TestMsg], re:split(Msg1, " ", [{return, list}, {parts, 3}]))
+ after
+ 1000 ->
+ ?assert(false)
+ end,
+ %% make sure this event wasn't duplicated
+ receive
+ {io_request, From2, ReplyAs2, {put_chars, unicode, _Msg2}} ->
+ From2 ! {io_reply, ReplyAs2, ok},
+ ?assert(false)
+ after
+ 500 ->
+ ?assert(true)
+ end
+ end
+ },
+ {"blacklisting a loglevel works",
+ fun() ->
+ Pid = spawn(F(self())),
+ unregister(user),
+ register(user, Pid),
+ gen_event:add_handler(lager_event, lager_console_backend, [{level, info}]),
+ lager_config:set({lager_event, loglevel}, {element(2, lager_util:config_to_mask(info)), []}),
+ lager:set_loglevel(lager_console_backend, '!=info'),
+ erlang:group_leader(Pid, whereis(lager_event)),
+ lager:debug("Test message"),
+ receive
+ {io_request, From1, ReplyAs1, {put_chars, unicode, Msg1}} ->
+ From1 ! {io_reply, ReplyAs1, ok},
+ TestMsg = "Test message" ++ eol(),
+ ?assertMatch([_, "[debug]", TestMsg], re:split(Msg1, " ", [{return, list}, {parts, 3}]))
+ after
+ 1000 ->
+ ?assert(false)
+ end,
+ %% info is blacklisted
+ lager:info("Test message"),
+ receive
+ {io_request, From2, ReplyAs2, {put_chars, unicode, _Msg2}} ->
+ From2 ! {io_reply, ReplyAs2, ok},
+ ?assert(false)
+ after
+ 500 ->
+ ?assert(true)
+ end
+ end
+ },
+ {"whitelisting a loglevel works",
+ fun() ->
+ Pid = spawn(F(self())),
+ unregister(user),
+ register(user, Pid),
+ gen_event:add_handler(lager_event, lager_console_backend, [{level, info}]),
+ lager_config:set({lager_event, loglevel}, {element(2, lager_util:config_to_mask(info)), []}),
+ lager:set_loglevel(lager_console_backend, '=debug'),
+ erlang:group_leader(Pid, whereis(lager_event)),
+ lager:debug("Test message"),
+ receive
+ {io_request, From1, ReplyAs1, {put_chars, unicode, Msg1}} ->
+ From1 ! {io_reply, ReplyAs1, ok},
+ TestMsg = "Test message" ++ eol(),
+ ?assertMatch([_, "[debug]", TestMsg], re:split(Msg1, " ", [{return, list}, {parts, 3}]))
+ after
+ 1000 ->
+ ?assert(false)
+ end,
+ %% info is blacklisted
+ lager:error("Test message"),
+ receive
+ {io_request, From2, ReplyAs2, {put_chars, unicode, _Msg2}} ->
+ From2 ! {io_reply, ReplyAs2, ok},
+ ?assert(false)
+ after
+ 500 ->
+ ?assert(true)
+ end
+ end
+ },
+ {"console backend with custom group leader",
+ fun() ->
+ Pid = spawn(F(self())),
+ gen_event:add_handler(lager_event, lager_console_backend, [{level, info}, {group_leader, Pid}]),
+ lager_config:set({lager_event, loglevel}, {element(2, lager_util:config_to_mask(info)), []}),
+ lager:info("Test message"),
+ ?assertNotEqual({group_leader, Pid}, erlang:process_info(whereis(lager_event), group_leader)),
+ receive
+ {io_request, From1, ReplyAs1, {put_chars, unicode, Msg1}} ->
+ From1 ! {io_reply, ReplyAs1, ok},
+ TestMsg = "Test message" ++ eol(),
+ ?assertMatch([_, "[info]", TestMsg], re:split(Msg1, " ", [{return, list}, {parts, 3}]))
+ after
+ 1000 ->
+ ?assert(false)
+ end,
+ %% killing the pid should prevent any new log messages (to prove we haven't accidentally redirected
+ %% the group leader some other way
+ exit(Pid, kill),
+ timer:sleep(100),
+ %% additionally, check the lager backend has been removed (because the group leader process died)
+ ?assertNot(lists:member(lager_console_backend, gen_event:which_handlers(lager_event))),
+ lager:error("Test message"),
+ receive
+ {io_request, From2, ReplyAs2, {put_chars, unicode, _Msg2}} ->
+ From2 ! {io_reply, ReplyAs2, ok},
+ ?assert(false)
+ after
+ 500 ->
+ ?assert(true)
+ end
+ end
+ },
+ {"console backend with custom group leader using a trace and an ID",
+ fun() ->
+ Pid = spawn(F(self())),
+ ID = {?MODULE, trace_test},
+ Handlers = lager_config:global_get(handlers, []),
+ HandlerInfo = lager_app:start_handler(lager_event, ID,
+ [{level, none}, {group_leader, Pid},
+ {id, ID}]),
+ lager_config:global_set(handlers, [HandlerInfo|Handlers]),
+ lager:info("Test message"),
+ ?assertNotEqual({group_leader, Pid}, erlang:process_info(whereis(lager_event), group_leader)),
+ receive
+ {io_request, From, ReplyAs, {put_chars, unicode, _Msg}} ->
+ From ! {io_reply, ReplyAs, ok},
+ ?assert(false)
+ after
+ 500 ->
+ ?assert(true)
+ end,
+ lager:trace(ID, [{module, ?MODULE}], debug),
+ lager:info("Test message"),
+ receive
+ {io_request, From1, ReplyAs1, {put_chars, unicode, Msg1}} ->
+ From1 ! {io_reply, ReplyAs1, ok},
+ TestMsg = "Test message" ++ eol(),
+ ?assertMatch([_, "[info]", TestMsg], re:split(Msg1, " ", [{return, list}, {parts, 3}]))
+ after
+ 500 ->
+ ?assert(false)
+ end,
+ ?assertNotEqual({0, []}, lager_config:get({lager_event, loglevel})),
+ %% killing the pid should prevent any new log messages (to prove we haven't accidentally redirected
+ %% the group leader some other way
+ exit(Pid, kill),
+ timer:sleep(100),
+ %% additionally, check the lager backend has been removed (because the group leader process died)
+ ?assertNot(lists:member(lager_console_backend, gen_event:which_handlers(lager_event))),
+ %% finally, check the trace has been removed
+ ?assertEqual({0, []}, lager_config:get({lager_event, loglevel})),
+ lager:error("Test message"),
+ receive
+ {io_request, From3, ReplyAs3, {put_chars, unicode, _Msg3}} ->
+ From3 ! {io_reply, ReplyAs3, ok},
+ ?assert(false)
+ after
+ 500 ->
+ ?assert(true)
+ end
+ end
+ }
+ ]
+ }.
+
+set_loglevel_test_() ->
+ {foreach,
+ fun() ->
+ error_logger:tty(false),
+ application:load(lager),
+ application:set_env(lager, handlers, [{lager_console_backend, [{level, info}]}]),
+ application:set_env(lager, error_logger_redirect, false),
+ lager:start()
+ end,
+ fun(_) ->
+ application:stop(lager),
+ application:stop(goldrush),
+ error_logger:tty(true)
+ end,
+ [
+ {"Get/set loglevel test",
+ fun() ->
+ ?assertEqual(info, lager:get_loglevel(lager_console_backend)),
+ lager:set_loglevel(lager_console_backend, debug),
+ ?assertEqual(debug, lager:get_loglevel(lager_console_backend)),
+ lager:set_loglevel(lager_console_backend, '!=debug'),
+ ?assertEqual(info, lager:get_loglevel(lager_console_backend)),
+ lager:set_loglevel(lager_console_backend, '!=info'),
+ ?assertEqual(debug, lager:get_loglevel(lager_console_backend)),
+ ok
+ end
+ },
+ {"Get/set invalid loglevel test",
+ fun() ->
+ ?assertEqual(info, lager:get_loglevel(lager_console_backend)),
+ ?assertEqual({error, bad_log_level},
+ lager:set_loglevel(lager_console_backend, fatfinger)),
+ ?assertEqual(info, lager:get_loglevel(lager_console_backend))
+ end
+ }
+
+ ]
+ }.
+
+-endif.

guam-0.9.11.tar.gz/_checkouts/lager/src/lager_crash_log.erl Added

@@ -0,0 +1,382 @@
+%% -------------------------------------------------------------------
+%%
+%% Copyright (c) 2011-2017 Basho Technologies, Inc.
+%%
+%% This file is provided to you 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.
+%%
+%% -------------------------------------------------------------------
+
+%% @doc Lager crash log writer. This module implements a gen_server which writes
+%% error_logger error messages out to a file in their original format. The
+%% location to which it logs is configured by the application var `crash_log'.
+%% Omitting this variable disables crash logging. Crash logs are printed safely
+%% using trunc_io via code mostly lifted from riak_err.
+%%
+%% The `crash_log_msg_size' application var is used to specify the maximum
+%% size of any message to be logged. `crash_log_size' is used to specify the
+%% maximum size of the crash log before it will be rotated (0 will disable).
+%% Time based rotation is configurable via `crash_log_date', the syntax is
+%% documented in the README. To control the number of rotated files to be
+%% retained, use `crash_log_count'.
+
+-module(lager_crash_log).
+
+-include("lager.hrl").
+
+-behaviour(gen_server).
+
+-ifdef(TEST).
+-include_lib("eunit/include/eunit.hrl").
+-include_lib("kernel/include/file.hrl").
+-endif.
+
+%% callbacks
+-export([init/1, handle_call/3, handle_cast/2, handle_info/2, terminate/2,
+ code_change/3]).
+
+-export([start_link/6, start/6]).
+
+-record(state, {
+ name :: string(),
+ fd :: pid() | undefined,
+ inode :: integer() | undefined,
+ ctime :: file:date_time() | undefined,
+ fmtmaxbytes :: integer(),
+ size :: integer(),
+ date :: undefined | string(),
+ count :: integer(),
+ flap=false :: boolean(),
+ rotator :: atom()
+}).
+
+%% @private
+start_link(Filename, MaxBytes, Size, Date, Count, Rotator) ->
+ gen_server:start_link({local, ?MODULE}, ?MODULE, [Filename, MaxBytes,
+ Size, Date, Count, Rotator], []).
+
+%% @private
+start(Filename, MaxBytes, Size, Date, Count, Rotator) ->
+ gen_server:start({local, ?MODULE}, ?MODULE, [Filename, MaxBytes, Size,
+ Date, Count, Rotator], []).
+
+%% @private
+init([RelFilename, MaxBytes, Size, Date, Count, Rotator]) ->
+ Filename = lager_util:expand_path(RelFilename),
+ case Rotator:open_logfile(Filename, false) of
+ {ok, {FD, Inode, Ctime, _Size}} ->
+ schedule_rotation(Date),
+ {ok, #state{name=Filename, fd=FD, inode=Inode, ctime=Ctime,
+ fmtmaxbytes=MaxBytes, size=Size, count=Count, date=Date,
+ rotator=Rotator}};
+ {error, Reason} ->
+ ?INT_LOG(error, "Failed to open crash log file ~ts with error: ~s",
+ [Filename, file:format_error(Reason)]),
+ {ok, #state{name=Filename, fmtmaxbytes=MaxBytes, flap=true,
+ size=Size, count=Count, date=Date, rotator=Rotator}}
+ end.
+
+%% @private
+handle_call({log, _} = Log, _From, State) ->
+ {Reply, NewState} = do_log(Log, State),
+ {reply, Reply, NewState};
+handle_call(_Call, _From, State) ->
+ {reply, ok, State}.
+
+%% @private
+handle_cast({log, _} = Log, State) ->
+ {_, NewState} = do_log(Log, State),
+ {noreply, NewState};
+handle_cast(_Request, State) ->
+ {noreply, State}.
+
+%% @private
+handle_info(rotate, #state{name=Name, count=Count, date=Date, rotator=Rotator} = State) ->
+ _ = Rotator:rotate_logfile(Name, Count),
+ schedule_rotation(Date),
+ {noreply, State};
+handle_info(_Info, State) ->
+ {noreply, State}.
+
+%% @private
+terminate(_Reason, _State) ->
+ ok.
+
+%% @private
+code_change(_OldVsn, State, _Extra) ->
+ {ok, State}.
+
+schedule_rotation(undefined) ->
+ ok;
+schedule_rotation(Date) ->
+ erlang:send_after(lager_util:calculate_next_rotation(Date) * 1000, self(), rotate),
+ ok.
+
+%% ===== Begin code lifted from riak_err =====
+
+-spec limited_fmt(string(), list(), integer()) -> iolist().
+%% @doc Format Fmt and Args similar to what io_lib:format/2 does but with
+%% limits on how large the formatted string may be.
+%%
+%% If the Args list's size is larger than TermMaxSize, then the
+%% formatting is done by trunc_io:print/2, where FmtMaxBytes is used
+%% to limit the formatted string's size.
+
+limited_fmt(Fmt, Args, FmtMaxBytes) ->
+ lager:safe_format(Fmt, Args, FmtMaxBytes).
+
+limited_str(Term, FmtMaxBytes) ->
+ {Str, _} = lager_trunc_io:print(Term, FmtMaxBytes),
+ Str.
+
+other_node_suffix(Pid) when node(Pid) =/= node() ->
+ "** at node " ++ atom_to_list(node(Pid)) ++ " **\n";
+other_node_suffix(_) ->
+ "".
+
+perhaps_a_sasl_report(error_report, {Pid, Type, Report}, FmtMaxBytes) ->
+ case lager_stdlib:is_my_error_report(Type) of
+ true ->
+ {sasl_type_to_report_head(Type), Pid,
+ sasl_limited_str(Type, Report, FmtMaxBytes), true};
+ false ->
+ {ignore, ignore, ignore, false}
+ end;
+%perhaps_a_sasl_report(info_report, {Pid, Type, Report}, FmtMaxBytes) ->
+ %case lager_stdlib:is_my_info_report(Type) of
+ %true ->
+ %{sasl_type_to_report_head(Type), Pid,
+ %sasl_limited_str(Type, Report, FmtMaxBytes), false};
+ %false ->
+ %{ignore, ignore, ignore, false}
+ %end;
+perhaps_a_sasl_report(_, _, _) ->
+ {ignore, ignore, ignore, false}.
+
+sasl_type_to_report_head(supervisor_report) ->
+ "SUPERVISOR REPORT";
+sasl_type_to_report_head(crash_report) ->
+ "CRASH REPORT";
+sasl_type_to_report_head(progress) ->
+ "PROGRESS REPORT".
+
+sasl_limited_str(supervisor_report, Report, FmtMaxBytes) ->
+ Name = lager_stdlib:sup_get(supervisor, Report),
+ Context = lager_stdlib:sup_get(errorContext, Report),
+ Reason = lager_stdlib:sup_get(reason, Report),
+ Offender = lager_stdlib:sup_get(offender, Report),
+ FmtString = " Supervisor: ~p~n Context: ~p~n Reason: "
+ "~s~n Offender: ~s~n~n",
+ {ReasonStr, _} = lager_trunc_io:print(Reason, FmtMaxBytes),
+ {OffenderStr, _} = lager_trunc_io:print(Offender, FmtMaxBytes),
+ io_lib:format(FmtString, [Name, Context, ReasonStr, OffenderStr]);
+sasl_limited_str(progress, Report, FmtMaxBytes) ->
+ [begin
+ {Str, _} = lager_trunc_io:print(Data, FmtMaxBytes),
+ io_lib:format(" ~16w: ~s~n", [Tag, Str])
+ end || {Tag, Data} <- Report];
+sasl_limited_str(crash_report, Report, FmtMaxBytes) ->
+ lager_stdlib:proc_lib_format(Report, FmtMaxBytes).
+
+do_log({log, Event}, #state{name=Name, fd=FD, inode=Inode, ctime=Ctime, flap=Flap,
+ fmtmaxbytes=FmtMaxBytes, size=RotSize, count=Count, rotator=Rotator} = State) ->
+ %% borrowed from riak_err
+ {ReportStr, Pid, MsgStr, _ErrorP} = case Event of
+ {error, _GL, {Pid1, Fmt, Args}} ->
+ {"ERROR REPORT", Pid1, limited_fmt(Fmt, Args, FmtMaxBytes), true};
+ {error_report, _GL, {Pid1, std_error, Rep}} ->
+ {"ERROR REPORT", Pid1, limited_str(Rep, FmtMaxBytes) ++ "\n", true};
+ {error_report, _GL, Other} ->
+ perhaps_a_sasl_report(error_report, Other, FmtMaxBytes);
+ _ ->
+ {ignore, ignore, ignore, false}
+ end,
+ if ReportStr == ignore ->
+ {ok, State};
+ true ->
+ case Rotator:ensure_logfile(Name, FD, Inode, Ctime, false) of
+ {ok, {_FD, _Inode, _Ctime, Size}} when RotSize /= 0, Size > RotSize ->
+ _ = Rotator:rotate_logfile(Name, Count),
+ handle_cast({log, Event}, State);
+ {ok, {NewFD, NewInode, NewCtime, _Size}} ->
+ {Date, TS} = lager_util:format_time(
+ lager_stdlib:maybe_utc(erlang:localtime())),
+ Time = [Date, " ", TS," =", ReportStr, "====\n"],
+ NodeSuffix = other_node_suffix(Pid),
+ Msg = io_lib:format("~s~s~s", [Time, MsgStr, NodeSuffix]),
+ case file:write(NewFD, unicode:characters_to_binary(Msg)) of
+ {error, Reason} when Flap == false ->
+ ?INT_LOG(error, "Failed to write log message to file ~ts: ~s",
+ [Name, file:format_error(Reason)]),
+ {ok, State#state{fd=NewFD, inode=NewInode, ctime=NewCtime, flap=true}};
+ ok ->
+ {ok, State#state{fd=NewFD, inode=NewInode, ctime=NewCtime, flap=false}};
+ _ ->
+ {ok, State#state{fd=NewFD, inode=NewInode, ctime=NewCtime}}
+ end;
+ {error, Reason} ->
+ case Flap of
+ true ->
+ {ok, State};
+ _ ->
+ ?INT_LOG(error, "Failed to reopen crash log ~ts with error: ~s",
+ [Name, file:format_error(Reason)]),
+ {ok, State#state{flap=true}}
+ end
+ end
+ end.
+
+
+-ifdef(TEST).
+
+filesystem_test_() ->
+ {foreach,
+ fun() ->
+ {ok, TestDir} = lager_util:create_test_dir(),
+ CrashLog = filename:join(TestDir, "crash_test.log"),
+ ok = lager_util:safe_write_file(CrashLog, []),
+ ok = error_logger:tty(false),
+ ok = lager_util:safe_application_load(lager),
+ ok = application:set_env(lager, handlers, [{lager_test_backend, info}]),
+ ok = application:set_env(lager, error_logger_redirect, true),
+ ok = application:unset_env(lager, crash_log),
+ ok = lager:start(),
+ ok = timer:sleep(1000),
+ ok = lager_test_backend:flush(),
+ CrashLog
+ end,
+ fun(_CrashLog) ->
+ case whereis(lager_crash_log) of
+ P when is_pid(P) ->
+ gen_server:stop(P);
+ _ ->
+ ok
+ end,
+ ok = application:stop(lager),
+ ok = application:stop(goldrush),
+ ok = lager_util:delete_test_dir(),
+ ok = error_logger:tty(true)
+ end, [
+ fun(CrashLog) ->
+ {"under normal circumstances, file should be opened",
+ fun() ->
+ {ok, _} = ?MODULE:start_link(CrashLog, 65535, 0, undefined, 0, lager_rotator_default),
+ _ = gen_event:which_handlers(error_logger),
+ sync_error_logger:error_msg("Test message\n"),
+ {ok, Bin} = file:read_file(CrashLog),
+ ?assertMatch([_, "Test message\n"], re:split(Bin, "\n", [{return, list}, {parts, 2}]))
+ end}
+ end,
+ fun(CrashLog) ->
+ {"file can't be opened on startup triggers an error message",
+ fun() ->
+ {ok, FInfo0} = file:read_file_info(CrashLog, [raw]),
+ FInfo1 = FInfo0#file_info{mode = 0},
+ ?assertEqual(ok, file:write_file_info(CrashLog, FInfo1)),
+ {ok, _} = ?MODULE:start_link(CrashLog, 65535, 0, undefined, 0, lager_rotator_default),
+ % Note: required on win32, do this early to prevent subsequent failures
+ % from preventing cleanup
+ ?assertEqual(ok, file:write_file_info(CrashLog, FInfo0)),
+ ?assertEqual(1, lager_test_backend:count()),
+ {_Level, _Time, Message,_Metadata} = lager_test_backend:pop(),
+ ?assertEqual(
+ "Failed to open crash log file " ++ CrashLog ++ " with error: permission denied",
+ lists:flatten(Message))
+ end}
+ end,
+ fun(CrashLog) ->
+ {"file that becomes unavailable at runtime should trigger an error message",
+ fun() ->
+ case os:type() of
+ {win32, _} ->
+ % Note: test is skipped on win32 due to the fact that a file can't be deleted or renamed
+ % while a process has an open file handle referencing it
+ ok;
+ _ ->
+ {ok, _} = ?MODULE:start_link(CrashLog, 65535, 0, undefined, 0, lager_rotator_default),
+ ?assertEqual(0, lager_test_backend:count()),
+ sync_error_logger:error_msg("Test message\n"),
+ _ = gen_event:which_handlers(error_logger),
+ ?assertEqual(1, lager_test_backend:count()),
+ ?assertEqual(ok, file:delete(CrashLog)),
+ ?assertEqual(ok, lager_util:safe_write_file(CrashLog, "")),
+ {ok, FInfo0} = file:read_file_info(CrashLog, [raw]),
+ FInfo1 = FInfo0#file_info{mode = 0},
+ ?assertEqual(ok, file:write_file_info(CrashLog, FInfo1)),
+ sync_error_logger:error_msg("Test message\n"),
+ _ = gen_event:which_handlers(error_logger),
+ % Note: required on win32, do this early to prevent subsequent failures
+ % from preventing cleanup
+ ?assertEqual(ok, file:write_file_info(CrashLog, FInfo0)),
+ ?assertEqual(3, lager_test_backend:count()),
+ lager_test_backend:pop(),
+ {_Level, _Time, Message,_Metadata} = lager_test_backend:pop(),
+ ?assertEqual(
+ "Failed to reopen crash log " ++ CrashLog ++ " with error: permission denied",
+ lists:flatten(Message))
+ end
+ end}
+ end,
+ fun(CrashLog) ->
+ {"unavailable files that are fixed at runtime should start having log messages written",
+ fun() ->
+ {ok, FInfo} = file:read_file_info(CrashLog, [raw]),
+ OldPerms = FInfo#file_info.mode,
+ file:write_file_info(CrashLog, FInfo#file_info{mode = 0}),
+ {ok, _} = ?MODULE:start_link(CrashLog, 65535, 0, undefined, 0, lager_rotator_default),
+ ?assertEqual(1, lager_test_backend:count()),
+ {_Level, _Time, Message,_Metadata} = lager_test_backend:pop(),
+ ?assertEqual(
+ "Failed to open crash log file " ++ CrashLog ++ " with error: permission denied",
+ lists:flatten(Message)),
+ file:write_file_info(CrashLog, FInfo#file_info{mode = OldPerms}),
+ sync_error_logger:error_msg("Test message~n"),
+ _ = gen_event:which_handlers(error_logger),
+ {ok, Bin} = file:read_file(CrashLog),
+ ?assertMatch([_, "Test message\n"], re:split(Bin, "\n", [{return, list}, {parts, 2}]))
+ end}
+ end,
+ fun(CrashLog) ->
+ {"external logfile rotation/deletion should be handled",
+ fun() ->
+ case os:type() of
+ {win32, _} ->
+ % Note: test is skipped on win32 due to the fact that a file can't be deleted or renamed
+ % while a process has an open file handle referencing it
+ ok;
+ _ ->
+ {ok, _} = ?MODULE:start_link(CrashLog, 65535, 0, undefined, 0, lager_rotator_default),
+ ?assertEqual(0, lager_test_backend:count()),
+ sync_error_logger:error_msg("Test message~n"),
+ _ = gen_event:which_handlers(error_logger),
+ {ok, Bin} = file:read_file(CrashLog),
+ ?assertMatch([_, "Test message\n"], re:split(Bin, "\n", [{return, list}, {parts, 2}])),
+ ?assertEqual(ok, file:delete(CrashLog)),
+ ?assertEqual(ok, lager_util:safe_write_file(CrashLog, "")),
+ sync_error_logger:error_msg("Test message1~n"),
+ _ = gen_event:which_handlers(error_logger),
+ {ok, Bin1} = file:read_file(CrashLog),
+ ?assertMatch([_, "Test message1\n"], re:split(Bin1, "\n", [{return, list}, {parts, 2}])),
+ file:rename(CrashLog, CrashLog ++ ".0"),
+ sync_error_logger:error_msg("Test message2~n"),
+ _ = gen_event:which_handlers(error_logger),
+ {ok, Bin2} = file:read_file(CrashLog),
+ ?assertMatch([_, "Test message2\n"], re:split(Bin2, "\n", [{return, list}, {parts, 2}]))
+ end
+ end}
+ end
+ ]}.
+
+-endif.
+

guam-0.9.11.tar.gz/_checkouts/lager/src/lager_default_formatter.erl Added

@@ -0,0 +1,571 @@
+%% Copyright (c) 2011-2012 Basho Technologies, Inc. All Rights Reserved.
+%%
+%% This file is provided to you 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.
+
+-module(lager_default_formatter).
+
+%%
+%% Include files
+%%
+-include("lager.hrl").
+-ifdef(TEST).
+-include_lib("eunit/include/eunit.hrl").
+-endif.
+
+%%
+%% Exported Functions
+%%
+-export([format/2, format/3]).
+
+%%
+%% API Functions
+%%
+
+%% @doc Provides a generic, default formatting for log messages using a semi-iolist as configuration. Any iolist allowed
+%% elements in the configuration are printed verbatim. Atoms in the configuration are treated as metadata properties
+%% and extracted from the log message. Optionally, a tuple of {atom(),semi-iolist()} can be used. The atom will look
+%% up the property, but if not found it will use the semi-iolist() instead. These fallbacks can be similarly nested
+%% or refer to other properties, if desired. You can also use a {atom, semi-iolist(), semi-iolist()} formatter, which
+%% acts like a ternary operator's true/false branches.
+%%
+%% The metadata properties date,time, message, severity, and sev will always exist. 
+%% The properties pid, file, line, module, and function will always exist if the parser transform is used.
+%%
+%% Example:
+%%
+%% `["Foo"]' -> "Foo", regardless of message content.
+%%
+%% `[message]' -> The content of the logged message, alone.
+%%
+%% `[{pid,"Unknown Pid"}]' -> "?.?.?" if pid is in the metadata, "Unknown Pid" if not.
+%%
+%% `[{pid, ["My pid is ", pid], ["Unknown Pid"]}]' -> if pid is in the metada print "My pid is ?.?.?", otherwise print "Unknown Pid"
+%% @end
+-spec format(lager_msg:lager_msg(),list(),list()) -> any().
+format(Msg,[], Colors) ->
+ format(Msg, [{eol, "\n"}], Colors);
+format(Msg,[{eol, EOL}], Colors) ->
+ Config = case application:get_env(lager, metadata_whitelist) of
+ undefined -> config(EOL, []);
+ {ok, Whitelist} -> config(EOL, Whitelist)
+ end,
+ format(Msg, Config, Colors);
+format(Message,Config,Colors) ->
+ [ case V of
+ color -> output_color(Message,Colors);
+ _ -> output(V,Message) 
+ end || V <- Config ].
+
+-spec format(lager_msg:lager_msg(),list()) -> any().
+format(Msg, Config) ->
+ format(Msg, Config, []).
+
+-spec output(term(),lager_msg:lager_msg()) -> iolist().
+output(message,Msg) -> lager_msg:message(Msg);
+output(date,Msg) ->
+ {D, _T} = lager_msg:datetime(Msg),
+ D;
+output(time,Msg) ->
+ {_D, T} = lager_msg:datetime(Msg),
+ T;
+output(severity,Msg) ->
+ atom_to_list(lager_msg:severity(Msg));
+output(severity_upper, Msg) ->
+ uppercase_severity(lager_msg:severity(Msg));
+output(blank,_Msg) ->
+ output({blank," "},_Msg);
+output(node, _Msg) ->
+ output({node, atom_to_list(node())},_Msg);
+output({blank,Fill},_Msg) ->
+ Fill;
+output(sev,Msg) ->
+ %% Write brief acronym for the severity level (e.g. debug -> $D)
+ [lager_util:level_to_chr(lager_msg:severity(Msg))];
+output(metadata, Msg) ->
+ output({metadata, "=", " "}, Msg);
+output({metadata, IntSep, FieldSep}, Msg) ->
+ MD = lists:keysort(1, lager_msg:metadata(Msg)),
+ string:join([io_lib:format("~s~s~p", [K, IntSep, V]) || {K, V} <- MD], FieldSep);
+output({pterm, Key}, Msg) ->
+ output({pterm, Key, ""}, Msg);
+output({pterm, Key, Default}, _Msg) ->
+ make_printable(maybe_get_persistent_term(Key, Default));
+output(Prop,Msg) when is_atom(Prop) ->
+ Metadata = lager_msg:metadata(Msg),
+ make_printable(get_metadata(Prop,Metadata,<<"Undefined">>));
+output({Prop,Default},Msg) when is_atom(Prop) ->
+ Metadata = lager_msg:metadata(Msg),
+ make_printable(get_metadata(Prop,Metadata,output(Default,Msg)));
+output({Prop, Present, Absent}, Msg) when is_atom(Prop) ->
+ %% sort of like a poor man's ternary operator
+ Metadata = lager_msg:metadata(Msg),
+ case get_metadata(Prop, Metadata) of
+ undefined ->
+ [ output(V, Msg) || V <- Absent];
+ _ ->
+ [ output(V, Msg) || V <- Present]
+ end;
+output({Prop, Present, Absent, Width}, Msg) when is_atom(Prop) ->
+ %% sort of like a poor man's ternary operator
+ Metadata = lager_msg:metadata(Msg),
+ case get_metadata(Prop, Metadata) of
+ undefined ->
+ [ output(V, Msg, Width) || V <- Absent];
+ _ ->
+ [ output(V, Msg, Width) || V <- Present]
+ end;
+output(Other,_) -> make_printable(Other).
+
+output(message, Msg, _Width) -> lager_msg:message(Msg);
+output(date,Msg, _Width) ->
+ {D, _T} = lager_msg:datetime(Msg),
+ D;
+output(time, Msg, _Width) ->
+ {_D, T} = lager_msg:datetime(Msg),
+ T;
+output(severity, Msg, Width) ->
+ make_printable(atom_to_list(lager_msg:severity(Msg)), Width);
+output(sev,Msg, _Width) ->
+ %% Write brief acronym for the severity level (e.g. debug -> $D)
+ [lager_util:level_to_chr(lager_msg:severity(Msg))];
+output(node, Msg, _Width) ->
+ output({node, atom_to_list(node())}, Msg, _Width);
+output(blank,_Msg, _Width) ->
+ output({blank, " "},_Msg, _Width);
+output({blank, Fill},_Msg, _Width) ->
+ Fill;
+output(metadata, Msg, _Width) ->
+ output({metadata, "=", " "}, Msg, _Width);
+output({metadata, IntSep, FieldSep}, Msg, _Width) ->
+ MD = lists:keysort(1, lager_msg:metadata(Msg)),
+ [string:join([io_lib:format("~s~s~p", [K, IntSep, V]) || {K, V} <- MD], FieldSep)];
+output({pterm, Key}, Msg, Width) ->
+ output({pterm, Key, ""}, Msg, Width);
+output({pterm, Key, Default}, _Msg, _Width) ->
+ make_printable(maybe_get_persistent_term(Key, Default));
+
+output(Prop, Msg, Width) when is_atom(Prop) ->
+ Metadata = lager_msg:metadata(Msg),
+ make_printable(get_metadata(Prop,Metadata,<<"Undefined">>), Width);
+output({Prop,Default},Msg, Width) when is_atom(Prop) ->
+ Metadata = lager_msg:metadata(Msg),
+ make_printable(get_metadata(Prop,Metadata,output(Default,Msg)), Width);
+output(Other,_, Width) -> make_printable(Other, Width).
+
+output_color(_Msg,[]) -> [];
+output_color(Msg,Colors) ->
+ Level = lager_msg:severity(Msg),
+ case lists:keyfind(Level, 1, Colors) of
+ {_, Color} -> Color;
+ _ -> []
+ end.
+
+-spec make_printable(any()) -> iolist().
+make_printable(A) when is_atom(A) -> atom_to_list(A);
+make_printable(P) when is_pid(P) -> pid_to_list(P);
+make_printable(L) when is_list(L) orelse is_binary(L) -> L; 
+make_printable(Other) -> io_lib:format("~p",[Other]).
+
+make_printable(A,W) when is_integer(W)-> string:left(make_printable(A),W);
+make_printable(A,{Align,W}) when is_integer(W) ->
+ case Align of
+ left ->
+ string:left(make_printable(A),W);
+ centre ->
+ string:centre(make_printable(A),W);
+ right ->
+ string:right(make_printable(A),W);
+ _ ->
+ string:left(make_printable(A),W)
+ end;
+
+make_printable(A,_W) -> make_printable(A).
+
+%% persistent term was introduced in OTP 21.2, so
+%% if we're running on an older OTP, just return the
+%% default value.
+-ifdef(OTP_RELEASE).
+maybe_get_persistent_term(Key, Default) ->
+ try
+ persistent_term:get(Key, Default)
+ catch
+ _:undef -> Default
+ end.
+-else.
+maybe_get_persistent_term(_Key, Default) -> Default.
+-endif.
+
+run_function(Function, Default) ->
+ try Function() of
+ Result ->
+ Result
+ catch
+ _:_ ->
+ Default
+ end.
+
+get_metadata(Key, Metadata) ->
+ get_metadata(Key, Metadata, undefined).
+
+get_metadata(Key, Metadata, Default) ->
+ case lists:keyfind(Key, 1, Metadata) of
+ false ->
+ Default;
+ {Key, Value} when is_function(Value) ->
+ run_function(Value, Default);
+ {Key, Value} ->
+ Value
+ end.
+
+config(EOL, []) ->
+ [
+ date, " ", time, " ", color, "[", severity, "] ",
+ {pid, ""},
+ {module, [
+ {pid, ["@"], ""},
+ module,
+ {function, [":", function], ""},
+ {line, [":",line], ""}], ""},
+ " ", message, EOL
+ ];
+config(EOL, MetaWhitelist) ->
+ [
+ date, " ", time, " ", color, "[", severity, "] ",
+ {pid, ""},
+ {module, [
+ {pid, ["@"], ""},
+ module,
+ {function, [":", function], ""},
+ {line, [":",line], ""}], ""},
+ " "
+ ] ++
+ [{M, [atom_to_list(M), "=", M, " "], ""}|| M <- MetaWhitelist] ++
+ [message, EOL].
+
+
+
+uppercase_severity(debug) -> "DEBUG";
+uppercase_severity(info) -> "INFO";
+uppercase_severity(notice) -> "NOTICE";
+uppercase_severity(warning) -> "WARNING";
+uppercase_severity(error) -> "ERROR";
+uppercase_severity(critical) -> "CRITICAL";
+uppercase_severity(alert) -> "ALERT";
+uppercase_severity(emergency) -> "EMERGENCY".
+
+-ifdef(TEST).
+date_time_now() ->
+ Now = os:timestamp(),
+ {Date, Time} = lager_util:format_time(lager_util:maybe_utc(lager_util:localtime_ms(Now))),
+ {Date, Time, Now}.
+
+basic_test_() ->
+ {Date, Time, Now} = date_time_now(),
+ [{"Default formatting test",
+ ?_assertEqual(iolist_to_binary([Date, " ", Time, " [error] ", pid_to_list(self()), " Message\n"]),
+ iolist_to_binary(format(lager_msg:new("Message",
+ Now,
+ error,
+ [{pid, self()}],
+ []),
+ [])))
+ },
+ {"Basic Formatting",
+ ?_assertEqual(<<"Simplist Format">>,
+ iolist_to_binary(format(lager_msg:new("Message",
+ Now,
+ error,
+ [{pid, self()}],
+ []),
+ ["Simplist Format"])))
+ },
+ {"Default equivalent formatting test",
+ ?_assertEqual(iolist_to_binary([Date, " ", Time, " [error] ", pid_to_list(self()), " Message\n"]),
+ iolist_to_binary(format(lager_msg:new("Message",
+ Now,
+ error,
+ [{pid, self()}],
+ []),
+ [date, " ", time," [",severity,"] ",pid, " ", message, "\n"]
+ )))
+ },
+ {"Non existent metadata can default to string",
+ ?_assertEqual(iolist_to_binary([Date, " ", Time, " [error] Fallback Message\n"]),
+ iolist_to_binary(format(lager_msg:new("Message",
+ Now,
+ error,
+ [{pid, self()}],
+ []),
+ [date, " ", time," [",severity,"] ",{does_not_exist,"Fallback"}, " ", message, "\n"]
+ )))
+ },
+ {"Non existent metadata can default to other metadata",
+ ?_assertEqual(iolist_to_binary([Date, " ", Time, " [error] Fallback Message\n"]),
+ iolist_to_binary(format(lager_msg:new("Message",
+ Now,
+ error,
+ [{pid, "Fallback"}],
+ []),
+ [date, " ", time," [",severity,"] ",{does_not_exist,pid}, " ", message, "\n"]
+ )))
+ },
+ {"Non existent metadata can default to a string2",
+ ?_assertEqual(iolist_to_binary(["Unknown Pid"]),
+ iolist_to_binary(format(lager_msg:new("Message",
+ Now,
+ error,
+ [],
+ []),
+ [{pid, ["My pid is ", pid], ["Unknown Pid"]}]
+ )))
+ },
+ {"Metadata can have extra formatting",
+ ?_assertEqual(iolist_to_binary(["My pid is hello"]),
+ iolist_to_binary(format(lager_msg:new("Message",
+ Now,
+ error,
+ [{pid, hello}],
+ []),
+ [{pid, ["My pid is ", pid], ["Unknown Pid"]}]
+ )))
+ },
+ {"Metadata can have extra formatting1",
+ ?_assertEqual(iolist_to_binary(["servername"]),
+ iolist_to_binary(format(lager_msg:new("Message",
+ Now,
+ error,
+ [{pid, hello}, {server, servername}],
+ []),
+ [{server,{pid, ["(", pid, ")"], ["(Unknown Server)"]}}]
+ )))
+ },
+ {"Metadata can have extra formatting2",
+ ?_assertEqual(iolist_to_binary(["(hello)"]),
+ iolist_to_binary(format(lager_msg:new("Message",
+ Now,
+ error,
+ [{pid, hello}],
+ []),
+ [{server,{pid, ["(", pid, ")"], ["(Unknown Server)"]}}]
+ )))
+ },
+ {"Metadata can have extra formatting3",
+ ?_assertEqual(iolist_to_binary(["(Unknown Server)"]),
+ iolist_to_binary(format(lager_msg:new("Message",
+ Now,
+ error,
+ [],
+ []),
+ [{server,{pid, ["(", pid, ")"], ["(Unknown Server)"]}}]
+ )))
+ },
+ {"Metadata can be printed in its enterity",
+ ?_assertEqual(iolist_to_binary(["bar=2 baz=3 foo=1"]),
+ iolist_to_binary(format(lager_msg:new("Message",
+ Now,
+ error,
+ [{foo, 1}, {bar, 2}, {baz, 3}],
+ []),
+ [metadata]
+ )))
+ },
+ {"Metadata can be printed in its enterity with custom seperators",
+ ?_assertEqual(iolist_to_binary(["bar->2, baz->3, foo->1"]),
+ iolist_to_binary(format(lager_msg:new("Message",
+ Now,
+ error,
+ [{foo, 1}, {bar, 2}, {baz, 3}],
+ []),
+ [{metadata, "->", ", "}]
+ )))
+ },
+ {"Metadata can have extra formatting with width 1",
+ ?_assertEqual(iolist_to_binary(["(hello )(hello )(hello)(hello)(hello)"]),
+ iolist_to_binary(format(lager_msg:new("Message",
+ Now,
+ error,
+ [{pid, hello}],
+ []),
+ ["(",{pid, [pid], "", 10},")",
+ "(",{pid, [pid], "", {bad_align,10}},")",
+ "(",{pid, [pid], "", bad10},")",
+ "(",{pid, [pid], "", {right,bad20}},")",
+ "(",{pid, [pid], "", {bad_align,bad20}},")"]
+ )))
+ },
+ {"Metadata can have extra formatting with width 2",
+ ?_assertEqual(iolist_to_binary(["(hello )"]),
+ iolist_to_binary(format(lager_msg:new("Message",
+ Now,
+ error,
+ [{pid, hello}],
+ []),
+ ["(",{pid, [pid], "", {left,10}},")"]
+ )))
+ },
+ {"Metadata can have extra formatting with width 3",
+ ?_assertEqual(iolist_to_binary(["( hello)"]),
+ iolist_to_binary(format(lager_msg:new("Message",
+ Now,
+ error,
+ [{pid, hello}],
+ []),
+ ["(",{pid, [pid], "", {right,10}},")"]
+ )))
+ },
+ {"Metadata can have extra formatting with width 4",
+ ?_assertEqual(iolist_to_binary(["( hello )"]),
+ iolist_to_binary(format(lager_msg:new("Message",
+ Now,
+ error,
+ [{pid, hello}],
+ []),
+ ["(",{pid, [pid], "", {centre,10}},")"]
+ )))
+ },
+ {"Metadata can have extra formatting with width 5",
+ ?_assertEqual(iolist_to_binary(["error |hello ! ( hello )"]),
+ iolist_to_binary(format(lager_msg:new("Message",
+ Now,
+ error,
+ [{pid, hello}],
+ []),
+ [{x,"",[severity,{blank,"|"},pid], 10},"!",blank,"(",{pid, [pid], "", {centre,10}},")"]
+ )))
+ },
+ {"Metadata can have extra formatting with width 6",
+ ?_assertEqual(iolist_to_binary([Time,Date," bar=2 baz=3 foo=1 pid=hello EMessage"]),
+ iolist_to_binary(format(lager_msg:new("Message",
+ Now,
+ error,
+ [{pid, hello},{foo, 1}, {bar, 2}, {baz, 3}],
+ []),
+ [{x,"",[time]}, {x,"",[date],20},blank,{x,"",[metadata],30},blank,{x,"",[sev],10},message, {message,message,"", {right,20}}]
+ )))
+ },
+ {"Uppercase Severity Formatting - DEBUG",
+ ?_assertEqual(<<"DEBUG Simplist Format">>,
+ iolist_to_binary(format(lager_msg:new("Message",
+ Now,
+ debug,
+ [{pid, self()}],
+ []),
+ [severity_upper, " Simplist Format"])))
+ },
+ {"Uppercase Severity Formatting - INFO",
+ ?_assertEqual(<<"INFO Simplist Format">>,
+ iolist_to_binary(format(lager_msg:new("Message",
+ Now,
+ info,
+ [{pid, self()}],
+ []),
+ [severity_upper, " Simplist Format"])))
+ },
+ {"Uppercase Severity Formatting - NOTICE",
+ ?_assertEqual(<<"NOTICE Simplist Format">>,
+ iolist_to_binary(format(lager_msg:new("Message",
+ Now,
+ notice,
+ [{pid, self()}],
+ []),
+ [severity_upper, " Simplist Format"])))
+ },
+ {"Uppercase Severity Formatting - WARNING",
+ ?_assertEqual(<<"WARNING Simplist Format">>,
+ iolist_to_binary(format(lager_msg:new("Message",
+ Now,
+ warning,
+ [{pid, self()}],
+ []),
+ [severity_upper, " Simplist Format"])))
+ },
+ {"Uppercase Severity Formatting - ERROR",
+ ?_assertEqual(<<"ERROR Simplist Format">>,
+ iolist_to_binary(format(lager_msg:new("Message",
+ Now,
+ error,
+ [{pid, self()}],
+ []),
+ [severity_upper, " Simplist Format"])))
+ },
+ {"Uppercase Severity Formatting - CRITICAL",
+ ?_assertEqual(<<"CRITICAL Simplist Format">>,
+ iolist_to_binary(format(lager_msg:new("Message",
+ Now,
+ critical,
+ [{pid, self()}],
+ []),
+ [severity_upper, " Simplist Format"])))
+ },
+ {"Uppercase Severity Formatting - ALERT",
+ ?_assertEqual(<<"ALERT Simplist Format">>,
+ iolist_to_binary(format(lager_msg:new("Message",
+ Now,
+ alert,
+ [{pid, self()}],
+ []),
+ [severity_upper, " Simplist Format"])))
+ },
+ {"Uppercase Severity Formatting - EMERGENCY",
+ ?_assertEqual(<<"EMERGENCY Simplist Format">>,
+ iolist_to_binary(format(lager_msg:new("Message",
+ Now,
+ emergency,
+ [{pid, self()}],
+ []),
+ [severity_upper, " Simplist Format"])))
+ },
+ {"pterm presence test",
+ %% skip test on OTP < 21
+ case list_to_integer(erlang:system_info(otp_release)) >= 21 of
+ true ->
+ ?_assertEqual(<<"Pterm is: something">>,
+ begin
+ persistent_term:put(thing, something),
+ Ret = iolist_to_binary(format(lager_msg:new("Message",
+ Now,
+ emergency,
+ [{pid, self()}],
+ []),
+ ["Pterm is: ", {pterm, thing}])),
+ persistent_term:erase(thing),
+ Ret
+ end);
+ false -> ?_assert(true)
+ end
+ },
+ {"pterm absence test",
+ ?_assertEqual(<<"Pterm is: nothing">>,
+ iolist_to_binary(format(lager_msg:new("Message",
+ Now,
+ emergency,
+ [{pid, self()}],
+ []),
+ ["Pterm is: ", {pterm, thing, "nothing"}])))
+ },
+ {"node formatting basic",
+ begin
+ [N, "foo"] = format(lager_msg:new("Message",
+ Now,
+ info,
+ [{pid, self()}],
+ []),
+ [node, "foo"]),
+ ?_assertNotMatch(nomatch, re:run(N, <<"@">>))
+ end
+ }
+ ].
+
+-endif.

guam-0.9.11.tar.gz/_checkouts/lager/src/lager_file_backend.erl Added

@@ -0,0 +1,1194 @@
+%% -------------------------------------------------------------------
+%%
+%% Copyright (c) 2011-2017 Basho Technologies, Inc.
+%%
+%% This file is provided to you 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.
+%%
+%% -------------------------------------------------------------------
+
+%% @doc File backend for lager, with multiple file support.
+%% Multiple files are supported, each with the path and the loglevel being
+%% configurable. The configuration paramter for this backend is a list of
+%% key-value 2-tuples. See the init() function for the available options.
+%% This backend supports external and internal log
+%% rotation and will re-open handles to files if the inode changes. It will
+%% also rotate the files itself if the size of the file exceeds the
+%% `size' and keep `count' rotated files. `date' is
+%% an alternate rotation trigger, based on time. See the README for
+%% documentation.
+%% For performance, the file backend does delayed writes, although it will
+%% sync at specific log levels, configured via the `sync_on' option. By default
+%% the error level or above will trigger a sync.
+
+-module(lager_file_backend).
+
+-include("lager.hrl").
+-include_lib("kernel/include/file.hrl").
+
+-behaviour(gen_event).
+
+-ifdef(TEST).
+-include_lib("eunit/include/eunit.hrl").
+-compile([{parse_transform, lager_transform}]).
+-endif.
+
+-export([init/1, handle_call/2, handle_event/2, handle_info/2, terminate/2,
+ code_change/3]).
+
+-export([config_to_id/1]).
+
+-define(DEFAULT_LOG_LEVEL, info).
+-define(DEFAULT_ROTATION_SIZE, 10485760). %% 10mb
+-define(DEFAULT_ROTATION_DATE, "$D0"). %% midnight
+-define(DEFAULT_ROTATION_COUNT, 5).
+-define(DEFAULT_ROTATION_MOD, lager_rotator_default).
+-define(DEFAULT_SYNC_LEVEL, error).
+-define(DEFAULT_SYNC_INTERVAL, 1000).
+-define(DEFAULT_SYNC_SIZE, 1024*64). %% 64kb
+-define(DEFAULT_CHECK_INTERVAL, 1000).
+
+-record(state, {
+ name :: string(),
+ level :: {'mask', integer()},
+ fd :: file:io_device() | undefined,
+ inode :: integer() | undefined,
+ ctime :: file:date_time() | undefined,
+ flap = false :: boolean(),
+ size = 0 :: integer(),
+ date :: undefined | string(),
+ count = 10 :: integer(),
+ rotator = lager_util :: atom(),
+ shaper :: lager_shaper(),
+ formatter :: atom(),
+ formatter_config :: any(),
+ sync_on :: {'mask', integer()},
+ check_interval = ?DEFAULT_CHECK_INTERVAL :: non_neg_integer(),
+ sync_interval = ?DEFAULT_SYNC_INTERVAL :: non_neg_integer(),
+ sync_size = ?DEFAULT_SYNC_SIZE :: non_neg_integer(),
+ last_check = os:timestamp() :: erlang:timestamp(),
+ os_type :: atom()
+ }).
+
+-type option() :: {file, string()} | {level, lager:log_level()} |
+ {size, non_neg_integer()} | {date, string()} |
+ {count, non_neg_integer()} | {rotator, atom()} |
+ {high_water_mark, non_neg_integer()} |
+ {flush_queue, boolean()} |
+ {flush_threshold, non_neg_integer()} |
+ {sync_interval, non_neg_integer()} |
+ {sync_size, non_neg_integer()} | {sync_on, lager:log_level()} |
+ {check_interval, non_neg_integer()} | {formatter, atom()} |
+ {formatter_config, term()}.
+
+-spec init([option(),...]) -> {ok, #state{}} | {error, {fatal,bad_config}}.
+init({FileName, LogLevel}) when is_list(FileName), is_atom(LogLevel) ->
+ %% backwards compatibility hack
+ init([{file, FileName}, {level, LogLevel}]);
+init({FileName, LogLevel, Size, Date, Count}) when is_list(FileName), is_atom(LogLevel) ->
+ %% backwards compatibility hack
+ init([{file, FileName}, {level, LogLevel}, {size, Size}, {date, Date}, {count, Count}]);
+init([{FileName, LogLevel, Size, Date, Count}, {Formatter,FormatterConfig}]) when is_list(FileName), is_atom(LogLevel), is_atom(Formatter) ->
+ %% backwards compatibility hack
+ init([{file, FileName}, {level, LogLevel}, {size, Size}, {date, Date}, {count, Count}, {formatter, Formatter}, {formatter_config, FormatterConfig}]);
+init([LogFile,{Formatter}]) ->
+ %% backwards compatibility hack
+ init([LogFile,{Formatter,[]}]);
+init([{FileName, LogLevel}, {Formatter,FormatterConfig}]) when is_list(FileName), is_atom(LogLevel), is_atom(Formatter) ->
+ %% backwards compatibility hack
+ init([{file, FileName}, {level, LogLevel}, {formatter, Formatter}, {formatter_config, FormatterConfig}]);
+init(LogFileConfig) when is_list(LogFileConfig) ->
+ case validate_logfile_proplist(LogFileConfig) of
+ false ->
+ %% falied to validate config
+ {error, {fatal, bad_config}};
+ Config ->
+ %% probabably a better way to do this, but whatever
+ [RelName, Level, Date, Size, Count, Rotator, HighWaterMark, Flush, SyncInterval, SyncSize, SyncOn, CheckInterval, Formatter, FormatterConfig] =
+ [proplists:get_value(Key, Config) || Key <- [file, level, date, size, count, rotator, high_water_mark, flush_queue, sync_interval, sync_size, sync_on, check_interval, formatter, formatter_config]],
+ FlushThr = proplists:get_value(flush_threshold, Config, 0),
+ Name = lager_util:expand_path(RelName),
+ schedule_rotation(Name, Date),
+ Shaper = lager_util:maybe_flush(Flush, #lager_shaper{hwm=HighWaterMark, flush_threshold = FlushThr, id=Name}),
+ State0 = #state{name=Name, level=Level, size=Size, date=Date, count=Count, rotator=Rotator,
+ shaper=Shaper, formatter=Formatter, formatter_config=FormatterConfig,
+ sync_on=SyncOn, sync_interval=SyncInterval, sync_size=SyncSize, check_interval=CheckInterval},
+ State = case Rotator:create_logfile(Name, {SyncSize, SyncInterval}) of
+ {ok, {FD, Inode, Ctime, _Size}} ->
+ State0#state{fd=FD, inode=Inode, ctime=Ctime};
+ {error, Reason} ->
+ ?INT_LOG(error, "Failed to open log file ~ts with error ~s", [Name, file:format_error(Reason)]),
+ State0#state{flap=true}
+ end,
+ {ok, State}
+ end.
+
+%% @private
+handle_call({set_loglevel, Level}, #state{name=Ident} = State) ->
+ case validate_loglevel(Level) of
+ false ->
+ {ok, {error, bad_loglevel}, State};
+ Levels ->
+ ?INT_LOG(notice, "Changed loglevel of ~s to ~p", [Ident, Level]),
+ {ok, ok, State#state{level=Levels}}
+ end;
+handle_call(get_loglevel, #state{level=Level} = State) ->
+ {ok, Level, State};
+handle_call({set_loghwm, Hwm}, #state{shaper=Shaper, name=Name} = State) ->
+ case validate_logfile_proplist([{file, Name}, {high_water_mark, Hwm}]) of
+ false ->
+ {ok, {error, bad_log_hwm}, State};
+ _ ->
+ NewShaper = Shaper#lager_shaper{hwm=Hwm},
+ ?INT_LOG(notice, "Changed loghwm of ~ts to ~p", [Name, Hwm]),
+ {ok, {last_loghwm, Shaper#lager_shaper.hwm}, State#state{shaper=NewShaper}}
+ end;
+handle_call(rotate, State = #state{name=File}) ->
+ {ok, NewState} = handle_info({rotate, File}, State),
+ {ok, ok, NewState};
+handle_call(_Request, State) ->
+ {ok, ok, State}.
+
+%% @private
+handle_event({log, Message},
+ #state{name=Name, level=L, shaper=Shaper, formatter=Formatter,formatter_config=FormatConfig} = State) ->
+ case lager_util:is_loggable(Message,L,{lager_file_backend, Name}) of
+ true ->
+ case lager_util:check_hwm(Shaper) of
+ {true, Drop, #lager_shaper{hwm=Hwm} = NewShaper} ->
+ NewState = case Drop > 0 of
+ true ->
+ Report = io_lib:format(
+ "lager_file_backend dropped ~p messages in the last second that exceeded the limit of ~p messages/sec",
+ [Drop, Hwm]),
+ ReportMsg = lager_msg:new(Report, warning, [], []),
+ write(State, lager_msg:timestamp(ReportMsg),
+ lager_msg:severity_as_int(ReportMsg), Formatter:format(ReportMsg, FormatConfig));
+ false ->
+ State
+ end,
+ {ok,write(NewState#state{shaper=NewShaper},
+ lager_msg:timestamp(Message), lager_msg:severity_as_int(Message),
+ Formatter:format(Message,FormatConfig))};
+ {false, _, #lager_shaper{dropped=D} = NewShaper} ->
+ {ok, State#state{shaper=NewShaper#lager_shaper{dropped=D+1}}}
+ end;
+ false ->
+ {ok, State}
+ end;
+handle_event(_Event, State) ->
+ {ok, State}.
+
+%% @private
+handle_info({rotate, File}, #state{name=File, count=Count, date=Date, rotator=Rotator}=State0) ->
+ State1 = close_file(State0),
+ _ = Rotator:rotate_logfile(File, Count),
+ schedule_rotation(File, Date),
+ {ok, State1};
+handle_info({shaper_expired, Name}, #state{shaper=Shaper, name=Name, formatter=Formatter, formatter_config=FormatConfig} = State) ->
+ _ = case Shaper#lager_shaper.dropped of
+ 0 ->
+ ok;
+ Dropped ->
+ Report = io_lib:format(
+ "lager_file_backend dropped ~p messages in the last second that exceeded the limit of ~p messages/sec",
+ [Dropped, Shaper#lager_shaper.hwm]),
+ ReportMsg = lager_msg:new(Report, warning, [], []),
+ write(State, lager_msg:timestamp(ReportMsg),
+ lager_msg:severity_as_int(ReportMsg), Formatter:format(ReportMsg, FormatConfig))
+ end,
+ {ok, State#state{shaper=Shaper#lager_shaper{dropped=0, mps=0, lasttime=os:timestamp()}}};
+handle_info(_Info, State) ->
+ {ok, State}.
+
+%% @private
+terminate(_Reason, State) ->
+ %% leaving this function call unmatched makes dialyzer cranky
+ _ = close_file(State),
+ ok.
+
+%% @private
+code_change(_OldVsn, State, _Extra) ->
+ {ok, State}.
+
+%% Convert the config into a gen_event handler ID
+config_to_id({Name,_Severity}) when is_list(Name) ->
+ {?MODULE, Name};
+config_to_id({Name,_Severity,_Size,_Rotation,_Count}) ->
+ {?MODULE, Name};
+config_to_id([{Name,_Severity,_Size,_Rotation,_Count}, _Format]) ->
+ {?MODULE, Name};
+config_to_id([{Name,_Severity}, _Format]) when is_list(Name) ->
+ {?MODULE, Name};
+config_to_id(Config) ->
+ case proplists:get_value(file, Config) of
+ undefined ->
+ erlang:error(no_file);
+ File ->
+ {?MODULE, File}
+ end.
+
+write(#state{name=Name, fd=FD,
+ inode=Inode, ctime=Ctime,
+ flap=Flap, size=RotSize,
+ count=Count, rotator=Rotator}=State0, Timestamp, Level, Msg) ->
+ case write_should_check(State0, Timestamp) of
+ true ->
+ %% need to check for rotation
+ Buffer = {State0#state.sync_size, State0#state.sync_interval},
+ case Rotator:ensure_logfile(Name, FD, Inode, Ctime, Buffer) of
+ {ok, {_FD, _Inode, _Ctime, Size}} when RotSize > 0, Size > RotSize ->
+ State1 = close_file(State0),
+ case Rotator:rotate_logfile(Name, Count) of
+ ok ->
+ %% go around the loop again, we'll do another rotation check and hit the next clause of ensure_logfile
+ write(State1, Timestamp, Level, Msg);
+ {error, Reason} ->
+ case Flap of
+ true ->
+ State1;
+ _ ->
+ ?INT_LOG(error, "Failed to rotate log file ~ts with error ~s", [Name, file:format_error(Reason)]),
+ State1#state{flap=true}
+ end
+ end;
+ {ok, {NewFD, NewInode, NewCtime, _Size}} ->
+ %% update our last check and try again
+ State1 = State0#state{last_check=Timestamp, fd=NewFD, inode=NewInode, ctime=NewCtime},
+ do_write(State1, Level, Msg);
+ {error, Reason} ->
+ case Flap of
+ true ->
+ State0;
+ _ ->
+ ?INT_LOG(error, "Failed to reopen log file ~ts with error ~s", [Name, file:format_error(Reason)]),
+ State0#state{flap=true}
+ end
+ end;
+ false ->
+ do_write(State0, Level, Msg)
+ end.
+
+write_should_check(#state{fd=undefined}, _Timestamp) ->
+ true;
+write_should_check(#state{last_check=LastCheck0, check_interval=CheckInterval,
+ name=Name, inode=Inode0, ctime=Ctime0}, Timestamp) ->
+ LastCheck1 = timer:now_diff(Timestamp, LastCheck0) div 1000,
+ case LastCheck1 >= CheckInterval of
+ true ->
+ true;
+ _ ->
+ % We need to know if the file has changed "out from under lager" so we don't
+ % write to an invalid FD
+ {Result, _FInfo} = lager_util:has_file_changed(Name, Inode0, Ctime0),
+ Result
+ end.
+
+do_write(#state{fd=FD, name=Name, flap=Flap} = State, Level, Msg) ->
+ %% delayed_write doesn't report errors
+ _ = file:write(FD, unicode:characters_to_binary(Msg)),
+ {mask, SyncLevel} = State#state.sync_on,
+ case (Level band SyncLevel) =/= 0 of
+ true ->
+ %% force a sync on any message that matches the 'sync_on' bitmask
+ Flap2 = case file:datasync(FD) of
+ {error, Reason2} when Flap == false ->
+ ?INT_LOG(error, "Failed to write log message to file ~ts: ~s",
+ [Name, file:format_error(Reason2)]),
+ true;
+ ok ->
+ false;
+ _ ->
+ Flap
+ end,
+ State#state{flap=Flap2};
+ _ ->
+ State
+ end.
+
+validate_loglevel(Level) ->
+ try lager_util:config_to_mask(Level) of
+ Levels ->
+ Levels
+ catch
+ _:_ ->
+ false
+ end.
+
+validate_logfile_proplist(List) ->
+ try validate_logfile_proplist(List, []) of
+ Res ->
+ case proplists:get_value(file, Res) of
+ undefined ->
+ ?INT_LOG(error, "Missing required file option", []),
+ false;
+ _File ->
+ %% merge with the default options
+ {ok, DefaultRotationDate} = lager_util:parse_rotation_date_spec(?DEFAULT_ROTATION_DATE),
+ lists:keymerge(1, lists:sort(Res), lists:sort([
+ {level, validate_loglevel(?DEFAULT_LOG_LEVEL)}, {date, DefaultRotationDate},
+ {size, ?DEFAULT_ROTATION_SIZE}, {count, ?DEFAULT_ROTATION_COUNT},
+ {rotator, ?DEFAULT_ROTATION_MOD},
+ {sync_on, validate_loglevel(?DEFAULT_SYNC_LEVEL)}, {sync_interval, ?DEFAULT_SYNC_INTERVAL},
+ {sync_size, ?DEFAULT_SYNC_SIZE}, {check_interval, ?DEFAULT_CHECK_INTERVAL},
+ {formatter, lager_default_formatter}, {formatter_config, []}
+ ]))
+ end
+ catch
+ {bad_config, Msg, Value} ->
+ ?INT_LOG(error, "~s ~p for file ~tp",
+ [Msg, Value, proplists:get_value(file, List)]),
+ false
+ end.
+
+validate_logfile_proplist([], Acc) ->
+ Acc;
+validate_logfile_proplist([{file, File}|Tail], Acc) ->
+ %% is there any reasonable validation we can do here?
+ validate_logfile_proplist(Tail, [{file, File}|Acc]);
+validate_logfile_proplist([{level, Level}|Tail], Acc) ->
+ case validate_loglevel(Level) of
+ false ->
+ throw({bad_config, "Invalid loglevel", Level});
+ Res ->
+ validate_logfile_proplist(Tail, [{level, Res}|Acc])
+ end;
+validate_logfile_proplist([{size, Size}|Tail], Acc) ->
+ case Size of
+ S when is_integer(S), S >= 0 ->
+ validate_logfile_proplist(Tail, [{size, Size}|Acc]);
+ _ ->
+ throw({bad_config, "Invalid rotation size", Size})
+ end;
+validate_logfile_proplist([{count, Count}|Tail], Acc) ->
+ case Count of
+ C when is_integer(C), C >= 0 ->
+ validate_logfile_proplist(Tail, [{count, Count}|Acc]);
+ _ ->
+ throw({bad_config, "Invalid rotation count", Count})
+ end;
+validate_logfile_proplist([{rotator, Rotator}|Tail], Acc) ->
+ case is_atom(Rotator) of
+ true ->
+ validate_logfile_proplist(Tail, [{rotator, Rotator}|Acc]);
+ false ->
+ throw({bad_config, "Invalid rotation module", Rotator})
+ end;
+validate_logfile_proplist([{high_water_mark, HighWaterMark}|Tail], Acc) ->
+ case HighWaterMark of
+ Hwm when is_integer(Hwm), Hwm >= 0 ->
+ validate_logfile_proplist(Tail, [{high_water_mark, Hwm}|Acc]);
+ _ ->
+ throw({bad_config, "Invalid high water mark", HighWaterMark})
+ end;
+validate_logfile_proplist([{date, Date}|Tail], Acc) ->
+ case lager_util:parse_rotation_date_spec(Date) of
+ {ok, Spec} ->
+ validate_logfile_proplist(Tail, [{date, Spec}|Acc]);
+ {error, _} when Date == "" ->
+ %% legacy config allowed blanks
+ validate_logfile_proplist(Tail, [{date, undefined}|Acc]);
+ {error, _} ->
+ throw({bad_config, "Invalid rotation date", Date})
+ end;
+validate_logfile_proplist([{sync_interval, SyncInt}|Tail], Acc) ->
+ case SyncInt of
+ Val when is_integer(Val), Val >= 0 ->
+ validate_logfile_proplist(Tail, [{sync_interval, Val}|Acc]);
+ _ ->
+ throw({bad_config, "Invalid sync interval", SyncInt})
+ end;
+validate_logfile_proplist([{sync_size, SyncSize}|Tail], Acc) ->
+ case SyncSize of
+ Val when is_integer(Val), Val >= 0 ->
+ validate_logfile_proplist(Tail, [{sync_size, Val}|Acc]);
+ _ ->
+ throw({bad_config, "Invalid sync size", SyncSize})
+ end;
+validate_logfile_proplist([{check_interval, CheckInt}|Tail], Acc) ->
+ case CheckInt of
+ Val when is_integer(Val), Val >= 0 ->
+ validate_logfile_proplist(Tail, [{check_interval, Val}|Acc]);
+ always ->
+ validate_logfile_proplist(Tail, [{check_interval, 0}|Acc]);
+ _ ->
+ throw({bad_config, "Invalid check interval", CheckInt})
+ end;
+validate_logfile_proplist([{sync_on, Level}|Tail], Acc) ->
+ case validate_loglevel(Level) of
+ false ->
+ throw({bad_config, "Invalid sync on level", Level});
+ Res ->
+ validate_logfile_proplist(Tail, [{sync_on, Res}|Acc])
+ end;
+validate_logfile_proplist([{formatter, Fmt}|Tail], Acc) ->
+ case is_atom(Fmt) of
+ true ->
+ validate_logfile_proplist(Tail, [{formatter, Fmt}|Acc]);
+ false ->
+ throw({bad_config, "Invalid formatter module", Fmt})
+ end;
+validate_logfile_proplist([{formatter_config, FmtCfg}|Tail], Acc) ->
+ case is_list(FmtCfg) of
+ true ->
+ validate_logfile_proplist(Tail, [{formatter_config, FmtCfg}|Acc]);
+ false ->
+ throw({bad_config, "Invalid formatter config", FmtCfg})
+ end;
+validate_logfile_proplist([{flush_queue, FlushCfg}|Tail], Acc) ->
+ case is_boolean(FlushCfg) of
+ true ->
+ validate_logfile_proplist(Tail, [{flush_queue, FlushCfg}|Acc]);
+ false ->
+ throw({bad_config, "Invalid queue flush flag", FlushCfg})
+ end;
+validate_logfile_proplist([{flush_threshold, Thr}|Tail], Acc) ->
+ case Thr of
+ _ when is_integer(Thr), Thr >= 0 ->
+ validate_logfile_proplist(Tail, [{flush_threshold, Thr}|Acc]);
+ _ ->
+ throw({bad_config, "Invalid queue flush threshold", Thr})
+ end;
+validate_logfile_proplist([Other|_Tail], _Acc) ->
+ throw({bad_config, "Invalid option", Other}).
+
+schedule_rotation(_, undefined) ->
+ ok;
+schedule_rotation(Name, Date) ->
+ erlang:send_after(lager_util:calculate_next_rotation(Date) * 1000, self(), {rotate, Name}),
+ ok.
+
+close_file(#state{fd=undefined} = State) ->
+ State;
+close_file(#state{fd=FD} = State) ->
+ %% Flush and close any file handles.
+ %% delayed write can cause file:close not to do a close
+ _ = file:datasync(FD),
+ _ = file:close(FD),
+ _ = file:close(FD),
+ State#state{fd=undefined}.
+
+-ifdef(TEST).
+
+get_loglevel_test() ->
+ {ok, Level, _} = handle_call(get_loglevel,
+ #state{name="bar", level=lager_util:config_to_mask(info), fd=0, inode=0, ctime=undefined}),
+ ?assertEqual(Level, lager_util:config_to_mask(info)),
+ {ok, Level2, _} = handle_call(get_loglevel,
+ #state{name="foo", level=lager_util:config_to_mask(warning), fd=0, inode=0, ctime=undefined}),
+ ?assertEqual(Level2, lager_util:config_to_mask(warning)).
+
+rotation_test_() ->
+ {foreach,
+ fun() ->
+ SyncLevel = validate_loglevel(?DEFAULT_SYNC_LEVEL),
+ SyncSize = ?DEFAULT_SYNC_SIZE,
+ SyncInterval = ?DEFAULT_SYNC_INTERVAL,
+ Rotator = ?DEFAULT_ROTATION_MOD,
+ CheckInterval = 0, %% hard to test delayed mode
+ {ok, TestDir} = lager_util:create_test_dir(),
+ TestLog = filename:join(TestDir, "test.log"),
+ {OsType, _} = os:type(),
+ #state{name=TestLog,
+ level=?DEBUG,
+ sync_on=SyncLevel,
+ sync_size=SyncSize,
+ sync_interval=SyncInterval,
+ check_interval=CheckInterval,
+ rotator=Rotator,
+ os_type=OsType}
+ end,
+ fun(#state{}) ->
+ ok = lager_util:delete_test_dir()
+ end, [
+ fun(DefaultState=#state{name=TestLog, os_type=OsType, sync_size=SyncSize, sync_interval=SyncInterval, rotator=Rotator}) ->
+ {"External rotation should work",
+ fun() ->
+ case OsType of
+ win32 ->
+ % Note: test is skipped on win32 due to the fact that a file can't be deleted or renamed
+ % while a process has an open file handle referencing it
+ ok;
+ _ ->
+ {ok, {FD, Inode, Ctime, _Size}} = Rotator:open_logfile(TestLog, {SyncSize, SyncInterval}),
+ State0 = DefaultState#state{fd=FD, inode=Inode, ctime=Ctime},
+ State1 = write(State0, os:timestamp(), ?DEBUG, "hello world"),
+ ?assertMatch(#state{name=TestLog, level=?DEBUG, fd=FD, inode=Inode, ctime=Ctime}, State1),
+ ?assertEqual(ok, file:delete(TestLog)),
+ State2 = write(State0, os:timestamp(), ?DEBUG, "hello world"),
+ %% assert file has changed
+ ExpState1 = #state{name=TestLog, level=?DEBUG, fd=FD, inode=Inode, ctime=Ctime},
+ ?assertNotEqual(ExpState1, State2),
+ ?assertMatch(#state{name=TestLog, level=?DEBUG}, State2),
+ ?assertEqual(ok, file:rename(TestLog, TestLog ++ ".1")),
+ State3 = write(State2, os:timestamp(), ?DEBUG, "hello world"),
+ %% assert file has changed
+ ?assertNotEqual(State3, State2),
+ ?assertMatch(#state{name=TestLog, level=?DEBUG}, State3),
+ ok
+ end
+ end}
+ end,
+ fun(DefaultState = #state{name=TestLog, sync_size=SyncSize, sync_interval=SyncInterval, rotator=Rotator}) ->
+ {"Internal rotation and delayed write",
+ fun() ->
+ TestLog0 = TestLog ++ ".0",
+ CheckInterval = 3000, % 3 sec
+ RotationSize = 15,
+ PreviousCheck = os:timestamp(),
+
+ {ok, {FD, Inode, Ctime, _Size}} = Rotator:open_logfile(TestLog, {SyncSize, SyncInterval}),
+ State0 = DefaultState#state{
+ fd=FD, inode=Inode, ctime=Ctime, size=RotationSize,
+ check_interval=CheckInterval, last_check=PreviousCheck},
+
+ %% new message within check interval with sync_on level
+ Msg1Timestamp = add_secs(PreviousCheck, 1),
+ State1 = write(State0, Msg1Timestamp, ?ERROR, "big big message 1"),
+ ?assertEqual(State0, State1),
+
+ %% new message within check interval under sync_on level
+ %% not written to disk yet
+ Msg2Timestamp = add_secs(PreviousCheck, 2),
+ State2 = write(State1, Msg2Timestamp, ?DEBUG, "buffered message 2"),
+ ?assertEqual(State0, State2),
+
+ % Note: we must ensure at least one second (DEFAULT_SYNC_INTERVAL) has passed
+ % for message 1 and 2 to be written to disk
+ ElapsedMs = timer:now_diff(os:timestamp(), PreviousCheck) div 1000,
+ case ElapsedMs > SyncInterval of
+ true ->
+ ok;
+ _ ->
+ S = SyncInterval - ElapsedMs,
+ timer:sleep(S)
+ end,
+
+ %% although file size is big enough...
+ {ok, FInfo} = file:read_file_info(TestLog, [raw]),
+ ?assert(RotationSize < FInfo#file_info.size),
+ %% ...no rotation yet
+ ?assertEqual(PreviousCheck, State2#state.last_check),
+ ?assertNot(filelib:is_regular(TestLog0)),
+
+ %% new message after check interval
+ Msg3Timestamp = add_secs(PreviousCheck, 4),
+ _State3 = write(State2, Msg3Timestamp, ?DEBUG, "message 3"),
+
+ %% rotation happened
+ ?assert(filelib:is_regular(TestLog0)),
+
+ {ok, Bin1} = file:read_file(TestLog0),
+ {ok, Bin2} = file:read_file(TestLog),
+ %% message 1-2 written to file
+ ?assertEqual(<<"big big message 1buffered message 2">>, Bin1),
+ %% message 3 buffered, not yet written to file
+ ?assertEqual(<<"">>, Bin2),
+ ok
+ end}
+ end
+ ]}.
+
+add_secs({Mega, Secs, Micro}, Add) ->
+ NewSecs = Secs + Add,
+ {Mega + NewSecs div 10000000, NewSecs rem 10000000, Micro}.
+
+filesystem_test_() ->
+ {foreach,
+ fun() ->
+ ok = error_logger:tty(false),
+ ok = lager_util:safe_application_load(lager),
+ ok = application:set_env(lager, handlers, [{lager_test_backend, info}]),
+ ok = application:set_env(lager, error_logger_redirect, false),
+ ok = application:set_env(lager, async_threshold, undefined),
+ {ok, _TestDir} = lager_util:create_test_dir(),
+ ok = lager:start(),
+ %% race condition where lager logs its own start up
+ %% makes several tests fail. See test/lager_test_backend
+ %% around line 800 for more information.
+ ok = timer:sleep(5),
+ ok = lager_test_backend:flush()
+ end,
+ fun(_) ->
+ ok = application:stop(lager),
+ ok = application:stop(goldrush),
+ ok = error_logger:tty(true),
+ ok = lager_util:delete_test_dir()
+ end, [
+ {"under normal circumstances, file should be opened",
+ fun() ->
+ {ok, TestDir} = lager_util:get_test_dir(),
+ TestLog = filename:join(TestDir, "test.log"),
+
+ gen_event:add_handler(lager_event, lager_file_backend,
+ [{TestLog, info}, {lager_default_formatter}]),
+ lager:log(error, self(), "Test message"),
+ {ok, Bin} = file:read_file(TestLog),
+ Pid = pid_to_list(self()),
+ ?assertMatch([_, _, "[error]", Pid, "Test message\n"],
+ re:split(Bin, " ", [{return, list}, {parts, 5}]))
+ end},
+ {"don't choke on unicode",
+ fun() ->
+ {ok, TestDir} = lager_util:get_test_dir(),
+ TestLog = filename:join(TestDir, "test.log"),
+
+ gen_event:add_handler(lager_event, lager_file_backend,
+ [{TestLog, info}, {lager_default_formatter}]),
+ lager:log(error, self(),"~ts", [[20013,25991,27979,35797]]),
+ {ok, Bin} = file:read_file(TestLog),
+ Pid = pid_to_list(self()),
+ ?assertMatch([_, _, "[error]", Pid,
+ [228,184,173,230,150,135,230,181,139,232,175,149, $\n]],
+ re:split(Bin, " ", [{return, list}, {parts, 5}]))
+ end},
+ {"don't choke on latin-1",
+ fun() ->
+ {ok, TestDir} = lager_util:get_test_dir(),
+ TestLog = filename:join(TestDir, "test.log"),
+
+ %% XXX if this test fails, check that this file is encoded latin-1, not utf-8!
+ gen_event:add_handler(lager_event, lager_file_backend,
+ [{TestLog, info}, {lager_default_formatter}]),
+ lager:log(error, self(),"~ts", [[76, 198, 221, 206, 78, $-, 239]]),
+ {ok, Bin} = file:read_file(TestLog),
+ Pid = pid_to_list(self()),
+ Res = re:split(Bin, " ", [{return, list}, {parts, 5}]),
+ ?assertMatch([_, _, "[error]", Pid,
+ [76,195,134,195,157,195,142,78,45,195,175,$\n]], Res)
+ end},
+ {"file can't be opened on startup triggers an error message",
+ fun() ->
+ {ok, TestDir} = lager_util:get_test_dir(),
+ TestLog = filename:join(TestDir, "test.log"),
+ ?assertEqual(ok, lager_util:safe_write_file(TestLog, [])),
+
+ {ok, FInfo0} = file:read_file_info(TestLog, [raw]),
+ FInfo1 = FInfo0#file_info{mode = 0},
+ ?assertEqual(ok, file:write_file_info(TestLog, FInfo1)),
+
+ gen_event:add_handler(lager_event, lager_file_backend,
+ {TestLog, info, 10*1024*1024, "$D0", 5}),
+
+ % Note: required on win32, do this early to prevent subsequent failures
+ % from preventing cleanup
+ ?assertEqual(ok, file:write_file_info(TestLog, FInfo0)),
+
+ ?assertEqual(1, lager_test_backend:count()),
+ {_Level, _Time, Message, _Metadata} = lager_test_backend:pop(),
+ MessageFlat = lists:flatten(Message),
+ ?assertEqual(
+ "Failed to open log file " ++ TestLog ++ " with error permission denied",
+ MessageFlat)
+ end},
+ {"file that becomes unavailable at runtime should trigger an error message",
+ fun() ->
+ case os:type() of
+ {win32, _} ->
+ % Note: test is skipped on win32 due to the fact that a file can't be
+ % deleted or renamed while a process has an open file handle referencing it
+ ok;
+ _ ->
+ {ok, TestDir} = lager_util:get_test_dir(),
+ TestLog = filename:join(TestDir, "test.log"),
+
+ gen_event:add_handler(lager_event, lager_file_backend,
+ [{file, TestLog}, {level, info}, {check_interval, 0}]),
+ ?assertEqual(0, lager_test_backend:count()),
+ lager:log(error, self(), "Test message"),
+ ?assertEqual(1, lager_test_backend:count()),
+ ?assertEqual(ok, file:delete(TestLog)),
+ ?assertEqual(ok, lager_util:safe_write_file(TestLog, "")),
+ {ok, FInfo0} = file:read_file_info(TestLog, [raw]),
+ FInfo1 = FInfo0#file_info{mode = 0},
+ ?assertEqual(ok, file:write_file_info(TestLog, FInfo1)),
+ lager:log(error, self(), "Test message"),
+ lager_test_backend:pop(),
+ lager_test_backend:pop(),
+ {_Level, _Time, Message, _Metadata} = lager_test_backend:pop(),
+ ?assertEqual(
+ "Failed to reopen log file " ++ TestLog ++ " with error permission denied",
+ lists:flatten(Message))
+ end
+ end},
+ {"unavailable files that are fixed at runtime should start having log messages written",
+ fun() ->
+ {ok, TestDir} = lager_util:get_test_dir(),
+ TestLog = filename:join(TestDir, "test.log"),
+ ?assertEqual(ok, lager_util:safe_write_file(TestLog, [])),
+
+ {ok, FInfo} = file:read_file_info(TestLog, [raw]),
+ OldPerms = FInfo#file_info.mode,
+ ?assertEqual(ok, file:write_file_info(TestLog, FInfo#file_info{mode = 0})),
+ gen_event:add_handler(lager_event, lager_file_backend,
+ [{file, TestLog},{check_interval, 0}]),
+ ?assertEqual(1, lager_test_backend:count()),
+ {_Level, _Time, Message, _Metadata} = lager_test_backend:pop(),
+ ?assertEqual(
+ "Failed to open log file " ++ TestLog ++ " with error permission denied",
+ lists:flatten(Message)),
+ ?assertEqual(ok, file:write_file_info(TestLog, FInfo#file_info{mode = OldPerms})),
+ lager:log(error, self(), "Test message"),
+ {ok, Bin} = file:read_file(TestLog),
+ Pid = pid_to_list(self()),
+ ?assertMatch([_, _, "[error]", Pid, "Test message\n"],
+ re:split(Bin, " ", [{return, list}, {parts, 5}]))
+ end},
+ {"external logfile rotation/deletion should be handled",
+ fun() ->
+ case os:type() of
+ {win32, _} ->
+ % Note: test is skipped on win32 due to the fact that a file can't be deleted or renamed
+ % while a process has an open file handle referencing it
+ ok;
+ _ ->
+ {ok, TestDir} = lager_util:get_test_dir(),
+ TestLog = filename:join(TestDir, "test.log"),
+ TestLog0 = TestLog ++ ".0",
+
+ gen_event:add_handler(lager_event, lager_file_backend,
+ [{file, TestLog}, {level, info}, {check_interval, 0}]),
+ ?assertEqual(0, lager_test_backend:count()),
+ lager:log(error, self(), "Test message1"),
+ ?assertEqual(1, lager_test_backend:count()),
+ ?assertEqual(ok, file:delete(TestLog)),
+ ?assertEqual(ok, lager_util:safe_write_file(TestLog, "")),
+ lager:log(error, self(), "Test message2"),
+ ?assertEqual(2, lager_test_backend:count()),
+ {ok, Bin} = file:read_file(TestLog),
+ Pid = pid_to_list(self()),
+ ?assertMatch([_, _, "[error]", Pid, "Test message2\n"],
+ re:split(Bin, " ", [{return, list}, {parts, 5}])),
+ ?assertEqual(ok, file:rename(TestLog, TestLog0)),
+ lager:log(error, self(), "Test message3"),
+ ?assertEqual(3, lager_test_backend:count()),
+ {ok, Bin2} = file:read_file(TestLog),
+ ?assertMatch([_, _, "[error]", Pid, "Test message3\n"],
+ re:split(Bin2, " ", [{return, list}, {parts, 5}]))
+ end
+ end},
+ {"internal size rotation should work",
+ fun() ->
+ {ok, TestDir} = lager_util:get_test_dir(),
+ TestLog = filename:join(TestDir, "test.log"),
+ TestLog0 = TestLog ++ ".0",
+
+ gen_event:add_handler(lager_event, lager_file_backend,
+ [{file, TestLog}, {level, info}, {check_interval, 0}, {size, 10}]),
+ lager:log(error, self(), "Test message1"),
+ lager:log(error, self(), "Test message1"),
+ ?assert(filelib:is_regular(TestLog0))
+ end},
+ {"internal time rotation should work",
+ fun() ->
+ {ok, TestDir} = lager_util:get_test_dir(),
+ TestLog = filename:join(TestDir, "test.log"),
+ TestLog0 = TestLog ++ ".0",
+
+ gen_event:add_handler(lager_event, lager_file_backend,
+ [{file, TestLog}, {level, info}, {check_interval, 1000}]),
+ lager:log(error, self(), "Test message1"),
+ lager:log(error, self(), "Test message1"),
+ whereis(lager_event) ! {rotate, TestLog},
+ lager:log(error, self(), "Test message1"),
+ ?assert(filelib:is_regular(TestLog0))
+ end},
+ {"rotation call should work",
+ fun() ->
+ {ok, TestDir} = lager_util:get_test_dir(),
+ TestLog = filename:join(TestDir, "test.log"),
+ TestLog0 = TestLog ++ ".0",
+
+ gen_event:add_handler(lager_event, {lager_file_backend, TestLog},
+ [{file, TestLog}, {level, info}, {check_interval, 1000}]),
+ lager:log(error, self(), "Test message1"),
+ lager:log(error, self(), "Test message1"),
+ gen_event:call(lager_event, {lager_file_backend, TestLog}, rotate, infinity),
+ lager:log(error, self(), "Test message1"),
+ ?assert(filelib:is_regular(TestLog0))
+ end},
+ {"sync_on option should work",
+ fun() ->
+ {ok, TestDir} = lager_util:get_test_dir(),
+ TestLog = filename:join(TestDir, "test.log"),
+
+ gen_event:add_handler(lager_event, lager_file_backend, [{file, TestLog},
+ {level, info}, {sync_on, "=info"}, {check_interval, 5000}, {sync_interval, 5000}]),
+ lager:log(error, self(), "Test message1"),
+ lager:log(error, self(), "Test message1"),
+ ?assertEqual({ok, <<>>}, file:read_file(TestLog)),
+ lager:log(info, self(), "Test message1"),
+ {ok, Bin} = file:read_file(TestLog),
+ ?assert(<<>> /= Bin)
+ end},
+ {"sync_on none option should work (also tests sync_interval)",
+ fun() ->
+ {ok, TestDir} = lager_util:get_test_dir(),
+ TestLog = filename:join(TestDir, "test.log"),
+
+ gen_event:add_handler(lager_event, lager_file_backend, [{file, TestLog},
+ {level, info}, {sync_on, "none"}, {check_interval, 5000}, {sync_interval, 1000}]),
+ lager:log(error, self(), "Test message1"),
+ lager:log(error, self(), "Test message1"),
+ ?assertEqual({ok, <<>>}, file:read_file(TestLog)),
+ lager:log(info, self(), "Test message1"),
+ ?assertEqual({ok, <<>>}, file:read_file(TestLog)),
+ timer:sleep(2000),
+ {ok, Bin} = file:read_file(TestLog),
+ ?assert(<<>> /= Bin)
+ end},
+ {"sync_size option should work",
+ fun() ->
+ {ok, TestDir} = lager_util:get_test_dir(),
+ TestLog = filename:join(TestDir, "test.log"),
+
+ gen_event:add_handler(lager_event, lager_file_backend, [{file, TestLog}, {level, info},
+ {sync_on, "none"}, {check_interval, 5001}, {sync_size, 640}, {sync_interval, 5001}]),
+ lager:log(error, self(), "Test messageis64bytes"),
+ lager:log(error, self(), "Test messageis64bytes"),
+ lager:log(error, self(), "Test messageis64bytes"),
+ lager:log(error, self(), "Test messageis64bytes"),
+ lager:log(error, self(), "Test messageis64bytes"),
+ ?assertEqual({ok, <<>>}, file:read_file(TestLog)),
+ lager:log(error, self(), "Test messageis64bytes"),
+ lager:log(error, self(), "Test messageis64bytes"),
+ lager:log(error, self(), "Test messageis64bytes"),
+ lager:log(error, self(), "Test messageis64bytes"),
+ ?assertEqual({ok, <<>>}, file:read_file(TestLog)),
+ %% now we've written enough bytes
+ lager:log(error, self(), "Test messageis64bytes"),
+ {ok, Bin} = file:read_file(TestLog),
+ ?assert(<<>> /= Bin)
+ end},
+ {"runtime level changes",
+ fun() ->
+ {ok, TestDir} = lager_util:get_test_dir(),
+ TestLog = filename:join(TestDir, "test.log"),
+
+ gen_event:add_handler(lager_event, {lager_file_backend, TestLog}, {TestLog, info}),
+ ?assertEqual(0, lager_test_backend:count()),
+ lager:log(info, self(), "Test message1"),
+ lager:log(error, self(), "Test message2"),
+ {ok, Bin} = file:read_file(TestLog),
+ Lines = length(re:split(Bin, "\n", [{return, list}, trim])),
+ ?assertEqual(Lines, 2),
+ ?assertEqual(ok, lager:set_loglevel(lager_file_backend, TestLog, warning)),
+ lager:log(info, self(), "Test message3"), %% this won't get logged
+ lager:log(error, self(), "Test message4"),
+ {ok, Bin2} = file:read_file(TestLog),
+ Lines2 = length(re:split(Bin2, "\n", [{return, list}, trim])),
+ ?assertEqual(Lines2, 3)
+ end},
+ {"invalid runtime level changes",
+ fun() ->
+ {ok, TestDir} = lager_util:get_test_dir(),
+ TestLog = filename:join(TestDir, "test.log"),
+ TestLog3 = filename:join(TestDir, "test3.log"),
+
+ gen_event:add_handler(lager_event, lager_file_backend,
+ [{TestLog, info, 10*1024*1024, "$D0", 5}, {lager_default_formatter}]),
+ gen_event:add_handler(lager_event, lager_file_backend, {TestLog3, info}),
+ ?assertEqual({error, bad_module}, lager:set_loglevel(lager_file_backend, TestLog, warning))
+ end},
+ {"tracing should work",
+ fun() ->
+ {ok, TestDir} = lager_util:get_test_dir(),
+ TestLog = filename:join(TestDir, "test.log"),
+
+ gen_event:add_handler(lager_event, lager_file_backend, {TestLog, critical}),
+ lager:error("Test message"),
+ ?assertEqual({ok, <<>>}, file:read_file(TestLog)),
+ {Level, _} = lager_config:get({lager_event, loglevel}),
+ lager_config:set({lager_event, loglevel}, {Level,
+ [{[{module, ?MODULE}], ?DEBUG, {lager_file_backend, TestLog}}]}),
+ lager:error("Test message"),
+ timer:sleep(1000),
+ {ok, Bin} = file:read_file(TestLog),
+ ?assertMatch([_, _, "[error]", _, "Test message\n"],
+ re:split(Bin, " ", [{return, list}, {parts, 5}]))
+ end},
+ {"tracing should not duplicate messages",
+ fun() ->
+ case os:type() of
+ {win32, _} ->
+ % Note: test is skipped on win32 due to the fact that a file can't be
+ % deleted or renamed while a process has an open file handle referencing it
+ ok;
+ _ ->
+ {ok, TestDir} = lager_util:get_test_dir(),
+ TestLog = filename:join(TestDir, "test.log"),
+
+ gen_event:add_handler(lager_event, lager_file_backend,
+ [{file, TestLog}, {level, critical}, {check_interval, always}]),
+ timer:sleep(500),
+ lager:critical("Test message"),
+ {ok, Bin1} = file:read_file(TestLog),
+ ?assertMatch([_, _, "[critical]", _, "Test message\n"],
+ re:split(Bin1, " ", [{return, list}, {parts, 5}])),
+ ?assertEqual(ok, file:delete(TestLog)),
+ {Level, _} = lager_config:get({lager_event, loglevel}),
+ lager_config:set({lager_event, loglevel},
+ {Level, [{[{module, ?MODULE}], ?DEBUG, {lager_file_backend, TestLog}}]}),
+ lager:critical("Test message"),
+ {ok, Bin2} = file:read_file(TestLog),
+ ?assertMatch([_, _, "[critical]", _, "Test message\n"],
+ re:split(Bin2, " ", [{return, list}, {parts, 5}])),
+ ?assertEqual(ok, file:delete(TestLog)),
+ lager:error("Test message"),
+ {ok, Bin3} = file:read_file(TestLog),
+ ?assertMatch([_, _, "[error]", _, "Test message\n"],
+ re:split(Bin3, " ", [{return, list}, {parts, 5}]))
+ end
+ end},
+ {"tracing to a dedicated file should work",
+ fun() ->
+ {ok, TestDir} = lager_util:get_test_dir(),
+ TestLog = filename:join(TestDir, "foo.log"),
+
+ {ok, _} = lager:trace_file(TestLog, [{module, ?MODULE}]),
+ lager:error("Test message"),
+ %% not eligible for trace
+ lager:log(error, self(), "Test message"),
+ {ok, Bin3} = file:read_file(TestLog),
+ ?assertMatch([_, _, "[error]", _, "Test message\n"],
+ re:split(Bin3, " ", [{return, list}, {parts, 5}]))
+ end},
+ {"tracing to a dedicated file should work even if root_log is set",
+ fun() ->
+ {ok, TestDir} = lager_util:get_test_dir(),
+ LogName = "foo.log",
+ LogPath = filename:join(TestDir, LogName),
+
+ application:set_env(lager, log_root, TestDir),
+ {ok, _} = lager:trace_file(LogName, [{module, ?MODULE}]),
+ lager:error("Test message"),
+ %% not eligible for trace
+ lager:log(error, self(), "Test message"),
+ {ok, Bin3} = file:read_file(LogPath),
+ application:unset_env(lager, log_root),
+ ?assertMatch([_, _, "[error]", _, "Test message\n"],
+ re:split(Bin3, " ", [{return, list}, {parts, 5}]))
+ end},
+ {"tracing with options should work",
+ fun() ->
+ {ok, TestDir} = lager_util:get_test_dir(),
+ TestLog = filename:join(TestDir, "foo.log"),
+ TestLog0 = TestLog ++ ".0",
+
+ {ok, _} = lager:trace_file(TestLog, [{module, ?MODULE}],
+ [{size, 20}, {check_interval, 1}]),
+ lager:error("Test message"),
+ ?assertNot(filelib:is_regular(TestLog0)),
+ %% rotation is sensitive to intervals between
+ %% writes so we sleep to exceed the 1
+ %% millisecond interval specified by
+ %% check_interval above
+ timer:sleep(2),
+ lager:error("Test message"),
+ timer:sleep(10),
+ ?assert(filelib:is_regular(TestLog0))
+ end},
+ {"no silent hwm drops",
+ fun() ->
+ MsgCount = 15,
+ {ok, TestDir} = lager_util:get_test_dir(),
+ TestLog = filename:join(TestDir, "test.log"),
+ gen_event:add_handler(lager_event, lager_file_backend, [{file, TestLog}, {level, info},
+ {high_water_mark, 5}, {flush_queue, false}, {sync_on, "=warning"}]),
+ {_, _, MS} = os:timestamp(),
+ % start close to the beginning of a new second
+ ?assertEqual(ok, timer:sleep((1000000 - MS) div 1000 + 1)),
+ [lager:log(info, self(), "Foo ~p", [K]) || K <- lists:seq(1, MsgCount)],
+ ?assertEqual(MsgCount, lager_test_backend:count()),
+ % Note: bumped from 1000 to 1250 to ensure delayed write flushes to disk
+ ?assertEqual(ok, timer:sleep(1250)),
+ {ok, Bin} = file:read_file(TestLog),
+ Last = lists:last(re:split(Bin, "\n", [{return, list}, trim])),
+ ?assertMatch([_, _, _, _, "lager_file_backend dropped 10 messages in the last second that exceeded the limit of 5 messages/sec"],
+ re:split(Last, " ", [{return, list}, {parts, 5}]))
+ end}
+ ]}.
+
+trace_files_test_() ->
+ {foreach,
+ fun() ->
+ {ok, TestDir} = lager_util:get_test_dir(),
+ Log = filename:join(TestDir, "test.log"),
+ Debug = filename:join(TestDir, "debug.log"),
+ Events = filename:join(TestDir, "events.log"),
+
+ ok = error_logger:tty(false),
+ ok = lager_util:safe_application_load(lager),
+ ok = application:set_env(lager, handlers, [
+ {lager_file_backend, [
+ {file, Log},
+ {level, error},
+ {formatter, lager_default_formatter},
+ {formatter_config, [message, "\n"]}
+ ]}
+ ]),
+ ok = application:set_env(lager, traces, [
+ { % get default level of debug
+ {lager_file_backend, Debug}, [{module, ?MODULE}]
+ },
+ { % Handler Filters Level
+ {lager_file_backend, Events}, [{module, ?MODULE}], notice
+ }
+ ]),
+ ok = application:set_env(lager, async_threshold, undefined),
+ ok = lager:start(),
+ {Log, Debug, Events}
+ end,
+ fun({_, _, _}) ->
+ catch ets:delete(lager_config),
+ ok = application:unset_env(lager, traces),
+ ok = application:stop(lager),
+ ok = lager_util:delete_test_dir(),
+ ok = error_logger:tty(true)
+ end, [
+ fun({Log, Debug, Events}) ->
+ {"a trace using file backend set up in configuration should work",
+ fun() ->
+ lager:error("trace test error message"),
+ lager:info("info message"),
+ %% not eligible for trace
+ lager:log(error, self(), "Not trace test message"),
+ {ok, BinInfo} = file:read_file(Events),
+ ?assertMatch([_, _, "[error]", _, "trace test error message\n"],
+ re:split(BinInfo, " ", [{return, list}, {parts, 5}])),
+ ?assert(filelib:is_regular(Log)),
+ {ok, BinInfo2} = file:read_file(Log),
+ ?assertMatch(["trace test error message", "Not trace test message\n"],
+ re:split(BinInfo2, "\n", [{return, list}, {parts, 2}])),
+ ?assert(filelib:is_regular(Debug)),
+ %% XXX Aughhhh, wish I could force this to flush somehow...
+ % should take about 1 second, try for 3 ...
+ ?assertEqual(2, count_lines_until(2, add_secs(os:timestamp(), 3), Debug, 0))
+ end}
+ end
+ ]}.
+
+count_lines_until(Lines, Timeout, File, Last) ->
+ case timer:now_diff(Timeout, os:timestamp()) > 0 of
+ true ->
+ timer:sleep(333),
+ {ok, Bin} = file:read_file(File),
+ case erlang:length(re:split(Bin, "\n", [{return, list}, trim])) of
+ Count when Count < Lines ->
+ count_lines_until(Lines, Timeout, File, Count);
+ Count ->
+ Count
+ end;
+ _ ->
+ Last
+ end.
+
+formatting_test_() ->
+ {foreach,
+ fun() ->
+ {ok, TestDir} = lager_util:get_test_dir(),
+ Log1 = filename:join(TestDir, "test.log"),
+ Log2 = filename:join(TestDir, "test2.log"),
+ ?assertEqual(ok, lager_util:safe_write_file(Log1, [])),
+ ?assertEqual(ok, lager_util:safe_write_file(Log2, [])),
+ ok = error_logger:tty(false),
+ ok = lager_util:safe_application_load(lager),
+ ok = application:set_env(lager, handlers, [{lager_test_backend, info}]),
+ ok = application:set_env(lager, error_logger_redirect, false),
+ ok = lager:start(),
+ %% same race condition issue
+ ok = timer:sleep(5),
+ {ok, Log1, Log2}
+ end,
+ fun({ok, _, _}) ->
+ ok = application:stop(lager),
+ ok = application:stop(goldrush),
+ ok = lager_util:delete_test_dir(),
+ ok = error_logger:tty(true)
+ end, [
+ fun({ok, Log1, Log2}) ->
+ {"Should have two log files, the second prefixed with 2>",
+ fun() ->
+ gen_event:add_handler(lager_event, lager_file_backend,
+ [{Log1, debug}, {lager_default_formatter, ["[",severity,"] ", message, "\n"]}]),
+ gen_event:add_handler(lager_event, lager_file_backend,
+ [{Log2, debug}, {lager_default_formatter, ["2> [",severity,"] ", message, "\n"]}]),
+ lager:log(error, self(), "Test message"),
+ ?assertMatch({ok, <<"[error] Test message\n">>},file:read_file(Log1)),
+ ?assertMatch({ok, <<"2> [error] Test message\n">>},file:read_file(Log2))
+ end}
+ end
+ ]}.
+
+config_validation_test_() ->
+ [
+ {"missing file",
+ ?_assertEqual(false,
+ validate_logfile_proplist([{level, info}, {size, 10}]))
+ },
+ {"bad level",
+ ?_assertEqual(false,
+ validate_logfile_proplist([{file, "test.log"}, {level, blah}, {size, 10}]))
+ },
+ {"bad size",
+ ?_assertEqual(false,
+ validate_logfile_proplist([{file, "test.log"}, {size, infinity}]))
+ },
+ {"bad count",
+ ?_assertEqual(false,
+ validate_logfile_proplist([{file, "test.log"}, {count, infinity}]))
+ },
+ {"bad high water mark",
+ ?_assertEqual(false,
+ validate_logfile_proplist([{file, "test.log"}, {high_water_mark, infinity}]))
+ },
+ {"bad date",
+ ?_assertEqual(false,
+ validate_logfile_proplist([{file, "test.log"}, {date, "midnight"}]))
+ },
+ {"blank date is ok",
+ ?_assertMatch([_|_],
+ validate_logfile_proplist([{file, "test.log"}, {date, ""}]))
+ },
+ {"bad sync_interval",
+ ?_assertEqual(false,
+ validate_logfile_proplist([{file, "test.log"}, {sync_interval, infinity}]))
+ },
+ {"bad sync_size",
+ ?_assertEqual(false,
+ validate_logfile_proplist([{file, "test.log"}, {sync_size, infinity}]))
+ },
+ {"bad check_interval",
+ ?_assertEqual(false,
+ validate_logfile_proplist([{file, "test.log"}, {check_interval, infinity}]))
+ },
+ {"bad sync_on level",
+ ?_assertEqual(false,
+ validate_logfile_proplist([{file, "test.log"}, {sync_on, infinity}]))
+ },
+ {"bad formatter module",
+ ?_assertEqual(false,
+ validate_logfile_proplist([{file, "test.log"}, {formatter, "io:format"}]))
+ },
+ {"bad formatter config",
+ ?_assertEqual(false,
+ validate_logfile_proplist([{file, "test.log"}, {formatter_config, blah}]))
+ },
+ {"unknown option",
+ ?_assertEqual(false,
+ validate_logfile_proplist([{file, "test.log"}, {rhubarb, spicy}]))
+ }
+ ].
+
+-endif.

guam-0.9.11.tar.gz/_checkouts/lager/src/lager_format.erl Added

@@ -0,0 +1,544 @@
+%%
+%% %CopyrightBegin%
+%% 
+%% Copyright Ericsson AB 1996-2011-2012. All Rights Reserved.
+%% 
+%% The contents of this file are subject to the Erlang Public License,
+%% Version 1.1, (the "License"); you may not use this file except in
+%% compliance with the License. You should have received a copy of the
+%% Erlang Public License along with this software. If not, it can be
+%% retrieved online at http://www.erlang.org/.
+%% 
+%% Software distributed under the License is distributed on an "AS IS"
+%% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
+%% the License for the specific language governing rights and limitations
+%% under the License.
+%% 
+%% %CopyrightEnd%
+%%
+-module(lager_format).
+
+%% fork of io_lib_format that uses trunc_io to protect against large terms
+
+-export([format/3, format/4]).
+
+-record(options, {
+ chomp = false :: boolean()
+ }).
+
+format(FmtStr, Args, MaxLen) ->
+ format(FmtStr, Args, MaxLen, []).
+
+format([], [], _, _) ->
+ "";
+format(FmtStr, Args, MaxLen, Opts) when is_atom(FmtStr) ->
+ format(atom_to_list(FmtStr), Args, MaxLen, Opts);
+format(FmtStr, Args, MaxLen, Opts) when is_binary(FmtStr) ->
+ format(binary_to_list(FmtStr), Args, MaxLen, Opts);
+format(FmtStr, Args, MaxLen, Opts) when is_list(FmtStr) ->
+ case io_lib:deep_char_list(FmtStr) of
+ true ->
+ Options = make_options(Opts, #options{}),
+ Cs = collect(FmtStr, Args),
+ {Cs2, MaxLen2} = build(Cs, [], MaxLen, Options),
+ %% count how many terms remain
+ {Count, StrLen} = lists:foldl(
+ fun({_C, _As, _F, _Adj, _P, _Pad, _Enc}, {Terms, Chars}) ->
+ {Terms + 1, Chars};
+ (_, {Terms, Chars}) ->
+ {Terms, Chars + 1}
+ end, {0, 0}, Cs2),
+ build2(Cs2, Count, MaxLen2 - StrLen);
+ false ->
+ erlang:error(badarg)
+ end;
+format(_FmtStr, _Args, _MaxLen, _Opts) ->
+ erlang:error(badarg).
+
+collect([$~|Fmt0], Args0) ->
+ {C,Fmt1,Args1} = collect_cseq(Fmt0, Args0),
+ [C|collect(Fmt1, Args1)];
+collect([C|Fmt], Args) ->
+ [C|collect(Fmt, Args)];
+collect([], []) -> [].
+
+collect_cseq(Fmt0, Args0) ->
+ {F,Ad,Fmt1,Args1} = field_width(Fmt0, Args0),
+ {P,Fmt2,Args2} = precision(Fmt1, Args1),
+ {Pad,Fmt3,Args3} = pad_char(Fmt2, Args2),
+ {Encoding,Fmt4,Args4} = encoding(Fmt3, Args3),
+ {C,As,Fmt5,Args5} = collect_cc(Fmt4, Args4),
+ {{C,As,F,Ad,P,Pad,Encoding},Fmt5,Args5}.
+
+encoding([$t|Fmt],Args) ->
+ {unicode,Fmt,Args};
+encoding(Fmt,Args) ->
+ {latin1,Fmt,Args}.
+
+field_width([$-|Fmt0], Args0) ->
+ {F,Fmt,Args} = field_value(Fmt0, Args0),
+ field_width(-F, Fmt, Args);
+field_width(Fmt0, Args0) ->
+ {F,Fmt,Args} = field_value(Fmt0, Args0),
+ field_width(F, Fmt, Args).
+
+field_width(F, Fmt, Args) when F < 0 ->
+ {-F,left,Fmt,Args};
+field_width(F, Fmt, Args) when F >= 0 ->
+ {F,right,Fmt,Args}.
+
+precision([$.|Fmt], Args) ->
+ field_value(Fmt, Args);
+precision(Fmt, Args) ->
+ {none,Fmt,Args}.
+
+field_value([$*|Fmt], [A|Args]) when is_integer(A) ->
+ {A,Fmt,Args};
+field_value([C|Fmt], Args) when is_integer(C), C >= $0, C =< $9 ->
+ field_value([C|Fmt], Args, 0);
+field_value(Fmt, Args) ->
+ {none,Fmt,Args}.
+
+field_value([C|Fmt], Args, F) when is_integer(C), C >= $0, C =< $9 ->
+ field_value(Fmt, Args, 10*F + (C - $0));
+field_value(Fmt, Args, F) -> %Default case
+ {F,Fmt,Args}.
+
+pad_char([$.,$*|Fmt], [Pad|Args]) -> {Pad,Fmt,Args};
+pad_char([$.,Pad|Fmt], Args) -> {Pad,Fmt,Args};
+pad_char(Fmt, Args) -> {$\s,Fmt,Args}.
+
+%% collect_cc([FormatChar], [Argument]) ->
+%% {Control,[ControlArg],[FormatChar],[Arg]}.
+%% Here we collect the argments for each control character.
+%% Be explicit to cause failure early.
+
+collect_cc([$w|Fmt], [A|Args]) -> {$w,[A],Fmt,Args};
+collect_cc([$p|Fmt], [A|Args]) -> {$p,[A],Fmt,Args};
+collect_cc([$W|Fmt], [A,Depth|Args]) -> {$W,[A,Depth],Fmt,Args};
+collect_cc([$P|Fmt], [A,Depth|Args]) -> {$P,[A,Depth],Fmt,Args};
+collect_cc([$s|Fmt], [A|Args]) -> {$s,[A],Fmt,Args};
+collect_cc([$e|Fmt], [A|Args]) -> {$e,[A],Fmt,Args};
+collect_cc([$f|Fmt], [A|Args]) -> {$f,[A],Fmt,Args};
+collect_cc([$g|Fmt], [A|Args]) -> {$g,[A],Fmt,Args};
+collect_cc([$b|Fmt], [A|Args]) -> {$b,[A],Fmt,Args};
+collect_cc([$B|Fmt], [A|Args]) -> {$B,[A],Fmt,Args};
+collect_cc([$x|Fmt], [A,Prefix|Args]) -> {$x,[A,Prefix],Fmt,Args};
+collect_cc([$X|Fmt], [A,Prefix|Args]) -> {$X,[A,Prefix],Fmt,Args};
+collect_cc([$+|Fmt], [A|Args]) -> {$+,[A],Fmt,Args};
+collect_cc([$#|Fmt], [A|Args]) -> {$#,[A],Fmt,Args};
+collect_cc([$c|Fmt], [A|Args]) -> {$c,[A],Fmt,Args};
+collect_cc([$~|Fmt], Args) when is_list(Args) -> {$~,[],Fmt,Args};
+collect_cc([$n|Fmt], Args) when is_list(Args) -> {$n,[],Fmt,Args};
+collect_cc([$i|Fmt], [A|Args]) -> {$i,[A],Fmt,Args}.
+
+
+%% build([Control], Pc, Indentation) -> [Char].
+%% Interpret the control structures. Count the number of print
+%% remaining and only calculate indentation when necessary. Must also
+%% be smart when calculating indentation for characters in format.
+
+build([{$n, _, _, _, _, _, _}], Acc, MaxLen, #options{chomp=true}) ->
+ %% trailing ~n, ignore
+ {lists:reverse(Acc), MaxLen};
+build([{C,As,F,Ad,P,Pad,Enc}|Cs], Acc, MaxLen, O) ->
+ {S, MaxLen2} = control(C, As, F, Ad, P, Pad, Enc, MaxLen),
+ build(Cs, [S|Acc], MaxLen2, O);
+build([$\n], Acc, MaxLen, #options{chomp=true}) ->
+ %% trailing \n, ignore
+ {lists:reverse(Acc), MaxLen};
+build([$\n|Cs], Acc, MaxLen, O) ->
+ build(Cs, [$\n|Acc], MaxLen - 1, O);
+build([$\t|Cs], Acc, MaxLen, O) ->
+ build(Cs, [$\t|Acc], MaxLen - 1, O);
+build([C|Cs], Acc, MaxLen, O) ->
+ build(Cs, [C|Acc], MaxLen - 1, O);
+build([], Acc, MaxLen, _O) ->
+ {lists:reverse(Acc), MaxLen}.
+
+build2([{C,As,F,Ad,P,Pad,Enc}|Cs], Count, MaxLen) ->
+ {S, Len} = control2(C, As, F, Ad, P, Pad, Enc, MaxLen div Count),
+ [S|build2(Cs, Count - 1, MaxLen - Len)];
+build2([C|Cs], Count, MaxLen) ->
+ [C|build2(Cs, Count, MaxLen)];
+build2([], _, _) -> [].
+
+%% control(FormatChar, [Argument], FieldWidth, Adjust, Precision, PadChar,
+%% Indentation) -> [Char]
+%% This is the main dispatch function for the various formatting commands.
+%% Field widths and precisions have already been calculated.
+
+control($e, [A], F, Adj, P, Pad, _Enc, L) when is_float(A) ->
+ Res = fwrite_e(A, F, Adj, P, Pad),
+ {Res, L - lists:flatlength(Res)};
+control($f, [A], F, Adj, P, Pad, _Enc, L) when is_float(A) ->
+ Res = fwrite_f(A, F, Adj, P, Pad),
+ {Res, L - lists:flatlength(Res)};
+control($g, [A], F, Adj, P, Pad, _Enc, L) when is_float(A) ->
+ Res = fwrite_g(A, F, Adj, P, Pad),
+ {Res, L - lists:flatlength(Res)};
+control($b, [A], F, Adj, P, Pad, _Enc, L) when is_integer(A) ->
+ Res = unprefixed_integer(A, F, Adj, base(P), Pad, true),
+ {Res, L - lists:flatlength(Res)};
+control($B, [A], F, Adj, P, Pad, _Enc, L) when is_integer(A) ->
+ Res = unprefixed_integer(A, F, Adj, base(P), Pad, false),
+ {Res, L - lists:flatlength(Res)};
+control($x, [A,Prefix], F, Adj, P, Pad, _Enc, L) when is_integer(A), 
+ is_atom(Prefix) ->
+ Res = prefixed_integer(A, F, Adj, base(P), Pad, atom_to_list(Prefix), true),
+ {Res, L - lists:flatlength(Res)};
+control($x, [A,Prefix], F, Adj, P, Pad, _Enc, L) when is_integer(A) ->
+ true = io_lib:deep_char_list(Prefix), %Check if Prefix a character list
+ Res = prefixed_integer(A, F, Adj, base(P), Pad, Prefix, true),
+ {Res, L - lists:flatlength(Res)};
+control($X, [A,Prefix], F, Adj, P, Pad, _Enc, L) when is_integer(A), 
+ is_atom(Prefix) ->
+ Res = prefixed_integer(A, F, Adj, base(P), Pad, atom_to_list(Prefix), false),
+ {Res, L - lists:flatlength(Res)};
+control($X, [A,Prefix], F, Adj, P, Pad, _Enc, L) when is_integer(A) ->
+ true = io_lib:deep_char_list(Prefix), %Check if Prefix a character list
+ Res = prefixed_integer(A, F, Adj, base(P), Pad, Prefix, false),
+ {Res, L - lists:flatlength(Res)};
+control($+, [A], F, Adj, P, Pad, _Enc, L) when is_integer(A) ->
+ Base = base(P),
+ Prefix = [integer_to_list(Base), $#],
+ Res = prefixed_integer(A, F, Adj, Base, Pad, Prefix, true),
+ {Res, L - lists:flatlength(Res)};
+control($#, [A], F, Adj, P, Pad, _Enc, L) when is_integer(A) ->
+ Base = base(P),
+ Prefix = [integer_to_list(Base), $#],
+ Res = prefixed_integer(A, F, Adj, Base, Pad, Prefix, false),
+ {Res, L - lists:flatlength(Res)};
+control($c, [A], F, Adj, P, Pad, unicode, L) when is_integer(A) ->
+ Res = char(A, F, Adj, P, Pad),
+ {Res, L - lists:flatlength(Res)};
+control($c, [A], F, Adj, P, Pad, _Enc, L) when is_integer(A) ->
+ Res = char(A band 255, F, Adj, P, Pad),
+ {Res, L - lists:flatlength(Res)};
+control($~, [], F, Adj, P, Pad, _Enc, L) ->
+ Res = char($~, F, Adj, P, Pad),
+ {Res, L - lists:flatlength(Res)};
+control($n, [], F, Adj, P, Pad, _Enc, L) ->
+ Res = newline(F, Adj, P, Pad),
+ {Res, L - lists:flatlength(Res)};
+control($i, [_A], _F, _Adj, _P, _Pad, _Enc, L) ->
+ {[], L};
+control($s, [A], F, Adj, P, Pad, _Enc, L) when is_atom(A) ->
+ Res = string(atom_to_list(A), F, Adj, P, Pad),
+ {Res, L - lists:flatlength(Res)};
+control(C, A, F, Adj, P, Pad, Enc, L) ->
+ %% save this for later - these are all the 'large' terms
+ {{C, A, F, Adj, P, Pad, Enc}, L}.
+
+control2($w, [A], F, Adj, P, Pad, _Enc, L) ->
+ Term = lager_trunc_io:fprint(A, L, [{lists_as_strings, false}]),
+ Res = term(Term, F, Adj, P, Pad),
+ {Res, lists:flatlength(Res)};
+control2($p, [A], _F, _Adj, _P, _Pad, _Enc, L) ->
+ Term = lager_trunc_io:fprint(A, L, [{lists_as_strings, true}]),
+ {Term, lists:flatlength(Term)};
+control2($W, [A,Depth], F, Adj, P, Pad, _Enc, L) when is_integer(Depth) ->
+ Term = lager_trunc_io:fprint(A, L, [{depth, Depth}, {lists_as_strings, false}]),
+ Res = term(Term, F, Adj, P, Pad),
+ {Res, lists:flatlength(Res)};
+control2($P, [A,Depth], _F, _Adj, _P, _Pad, _Enc, L) when is_integer(Depth) ->
+ Term = lager_trunc_io:fprint(A, L, [{depth, Depth}, {lists_as_strings, true}]),
+ {Term, lists:flatlength(Term)};
+control2($s, [L0], F, Adj, P, Pad, latin1, L) ->
+ List = lager_trunc_io:fprint(iolist_to_chars(L0), L, [{force_strings, true}]),
+ Res = string(List, F, Adj, P, Pad),
+ {Res, lists:flatlength(Res)};
+control2($s, [L0], F, Adj, P, Pad, unicode, L) ->
+ List = lager_trunc_io:fprint(cdata_to_chars(L0), L, [{force_strings, true}]),
+ Res = uniconv(string(List, F, Adj, P, Pad)),
+ {Res, lists:flatlength(Res)}.
+
+iolist_to_chars([C|Cs]) when is_integer(C), C >= $\000, C =< $\377 ->
+ [C | iolist_to_chars(Cs)];
+iolist_to_chars([I|Cs]) ->
+ [iolist_to_chars(I) | iolist_to_chars(Cs)];
+iolist_to_chars([]) ->
+ [];
+iolist_to_chars(B) when is_binary(B) ->
+ binary_to_list(B).
+
+cdata_to_chars([C|Cs]) when is_integer(C), C >= $\000 ->
+ [C | cdata_to_chars(Cs)];
+cdata_to_chars([I|Cs]) ->
+ [cdata_to_chars(I) | cdata_to_chars(Cs)];
+cdata_to_chars([]) ->
+ [];
+cdata_to_chars(B) when is_binary(B) ->
+ case catch unicode:characters_to_list(B) of
+ L when is_list(L) -> L;
+ _ -> binary_to_list(B)
+ end.
+
+make_options([], Options) ->
+ Options;
+make_options([{chomp, Bool}|T], Options) when is_boolean(Bool) ->
+ make_options(T, Options#options{chomp=Bool}).
+
+-ifdef(UNICODE_AS_BINARIES).
+uniconv(C) ->
+ unicode:characters_to_binary(C,unicode).
+-else.
+uniconv(C) ->
+ C.
+-endif.
+%% Default integer base
+base(none) ->
+ 10;
+base(B) when is_integer(B) ->
+ B.
+
+%% term(TermList, Field, Adjust, Precision, PadChar)
+%% Output the characters in a term.
+%% Adjust the characters within the field if length less than Max padding
+%% with PadChar.
+
+term(T, none, _Adj, none, _Pad) -> T;
+term(T, none, Adj, P, Pad) -> term(T, P, Adj, P, Pad);
+term(T, F, Adj, P0, Pad) ->
+ L = lists:flatlength(T),
+ P = case P0 of none -> erlang:min(L, F); _ -> P0 end,
+ if
+ L > P ->
+ adjust(chars($*, P), chars(Pad, F-P), Adj);
+ F >= P ->
+ adjust(T, chars(Pad, F-L), Adj)
+ end.
+
+%% fwrite_e(Float, Field, Adjust, Precision, PadChar)
+
+fwrite_e(Fl, none, Adj, none, Pad) -> %Default values
+ fwrite_e(Fl, none, Adj, 6, Pad);
+fwrite_e(Fl, none, _Adj, P, _Pad) when P >= 2 ->
+ float_e(Fl, float_data(Fl), P);
+fwrite_e(Fl, F, Adj, none, Pad) ->
+ fwrite_e(Fl, F, Adj, 6, Pad);
+fwrite_e(Fl, F, Adj, P, Pad) when P >= 2 ->
+ term(float_e(Fl, float_data(Fl), P), F, Adj, F, Pad).
+
+float_e(Fl, Fd, P) when Fl < 0.0 -> %Negative numbers
+ [$-|float_e(-Fl, Fd, P)];
+float_e(_Fl, {Ds,E}, P) ->
+ case float_man(Ds, 1, P-1) of
+ {[$0|Fs],true} -> [[$1|Fs]|float_exp(E)];
+ {Fs,false} -> [Fs|float_exp(E-1)]
+ end.
+
+%% float_man([Digit], Icount, Dcount) -> {[Chars],CarryFlag}.
+%% Generate the characters in the mantissa from the digits with Icount
+%% characters before the '.' and Dcount decimals. Handle carry and let
+%% caller decide what to do at top.
+
+float_man(Ds, 0, Dc) ->
+ {Cs,C} = float_man(Ds, Dc),
+ {[$.|Cs],C};
+float_man([D|Ds], I, Dc) ->
+ case float_man(Ds, I-1, Dc) of
+ {Cs,true} when D =:= $9 -> {[$0|Cs],true};
+ {Cs,true} -> {[D+1|Cs],false};
+ {Cs,false} -> {[D|Cs],false}
+ end;
+float_man([], I, Dc) -> %Pad with 0's
+ {string:chars($0, I, [$.|string:chars($0, Dc)]),false}.
+
+float_man([D|_], 0) when D >= $5 -> {[],true};
+float_man([_|_], 0) -> {[],false};
+float_man([D|Ds], Dc) ->
+ case float_man(Ds, Dc-1) of
+ {Cs,true} when D =:= $9 -> {[$0|Cs],true};
+ {Cs,true} -> {[D+1|Cs],false}; 
+ {Cs,false} -> {[D|Cs],false}
+ end;
+float_man([], Dc) -> {string:chars($0, Dc),false}. %Pad with 0's
+
+%% float_exp(Exponent) -> [Char].
+%% Generate the exponent of a floating point number. Always include sign.
+
+float_exp(E) when E >= 0 ->
+ [$e,$+|integer_to_list(E)];
+float_exp(E) ->
+ [$e|integer_to_list(E)].
+
+%% fwrite_f(FloatData, Field, Adjust, Precision, PadChar)
+
+fwrite_f(Fl, none, Adj, none, Pad) -> %Default values
+ fwrite_f(Fl, none, Adj, 6, Pad);
+fwrite_f(Fl, none, _Adj, P, _Pad) when P >= 1 ->
+ float_f(Fl, float_data(Fl), P);
+fwrite_f(Fl, F, Adj, none, Pad) ->
+ fwrite_f(Fl, F, Adj, 6, Pad);
+fwrite_f(Fl, F, Adj, P, Pad) when P >= 1 ->
+ term(float_f(Fl, float_data(Fl), P), F, Adj, F, Pad).
+
+float_f(Fl, Fd, P) when Fl < 0.0 ->
+ [$-|float_f(-Fl, Fd, P)];
+float_f(Fl, {Ds,E}, P) when E =< 0 ->
+ float_f(Fl, {string:chars($0, -E+1, Ds),1}, P); %Prepend enough 0's 
+float_f(_Fl, {Ds,E}, P) ->
+ case float_man(Ds, E, P) of
+ {Fs,true} -> "1" ++ Fs; %Handle carry
+ {Fs,false} -> Fs
+ end.
+
+%% float_data([FloatChar]) -> {[Digit],Exponent}
+
+float_data(Fl) ->
+ float_data(float_to_list(Fl), []).
+
+float_data([$e|E], Ds) ->
+ {lists:reverse(Ds),list_to_integer(E)+1};
+float_data([D|Cs], Ds) when D >= $0, D =< $9 ->
+ float_data(Cs, [D|Ds]);
+float_data([_|Cs], Ds) ->
+ float_data(Cs, Ds).
+
+%% fwrite_g(Float, Field, Adjust, Precision, PadChar)
+%% Use the f form if Float is >= 0.1 and < 1.0e4, 
+%% and the prints correctly in the f form, else the e form.
+%% Precision always means the # of significant digits.
+
+fwrite_g(Fl, F, Adj, none, Pad) ->
+ fwrite_g(Fl, F, Adj, 6, Pad);
+fwrite_g(Fl, F, Adj, P, Pad) when P >= 1 ->
+ A = abs(Fl),
+ E = if A < 1.0e-1 -> -2;
+ A < 1.0e0 -> -1;
+ A < 1.0e1 -> 0;
+ A < 1.0e2 -> 1;
+ A < 1.0e3 -> 2;
+ A < 1.0e4 -> 3;
+ true -> fwrite_f
+ end,
+ if P =< 1, E =:= -1;
+ P-1 > E, E >= -1 ->
+ fwrite_f(Fl, F, Adj, P-1-E, Pad);
+ P =< 1 ->
+ fwrite_e(Fl, F, Adj, 2, Pad);
+ true ->
+ fwrite_e(Fl, F, Adj, P, Pad)
+ end.
+
+
+%% string(String, Field, Adjust, Precision, PadChar)
+
+string(S, none, _Adj, none, _Pad) -> S;
+string(S, F, Adj, none, Pad) ->
+ string_field(S, F, Adj, lists:flatlength(S), Pad);
+string(S, none, _Adj, P, Pad) ->
+ string_field(S, P, left, lists:flatlength(S), Pad);
+string(S, F, Adj, P, Pad) when F >= P ->
+ N = lists:flatlength(S),
+ if F > P ->
+ if N > P ->
+ adjust(flat_trunc(S, P), chars(Pad, F-P), Adj);
+ N 
+ adjust([S|chars(Pad, P-N)], chars(Pad, F-P), Adj);
+ true -> % N == P
+ adjust(S, chars(Pad, F-P), Adj)
+ end;
+ true -> % F == P
+ string_field(S, F, Adj, N, Pad)
+ end.
+
+string_field(S, F, _Adj, N, _Pad) when N > F ->
+ flat_trunc(S, F);
+string_field(S, F, Adj, N, Pad) when N < F ->
+ adjust(S, chars(Pad, F-N), Adj);
+string_field(S, _, _, _, _) -> % N == F
+ S.
+
+%% unprefixed_integer(Int, Field, Adjust, Base, PadChar, Lowercase)
+%% -> [Char].
+
+unprefixed_integer(Int, F, Adj, Base, Pad, Lowercase)
+ when Base >= 2, Base =< 1+$Z-$A+10 ->
+ if Int < 0 ->
+ S = cond_lowercase(erlang:integer_to_list(-Int, Base), Lowercase),
+ term([$-|S], F, Adj, none, Pad);
+ true ->
+ S = cond_lowercase(erlang:integer_to_list(Int, Base), Lowercase),
+ term(S, F, Adj, none, Pad)
+ end.
+
+%% prefixed_integer(Int, Field, Adjust, Base, PadChar, Prefix, Lowercase)
+%% -> [Char].
+
+prefixed_integer(Int, F, Adj, Base, Pad, Prefix, Lowercase)
+ when Base >= 2, Base =< 1+$Z-$A+10 ->
+ if Int < 0 ->
+ S = cond_lowercase(erlang:integer_to_list(-Int, Base), Lowercase),
+ term([$-,Prefix|S], F, Adj, none, Pad);
+ true ->
+ S = cond_lowercase(erlang:integer_to_list(Int, Base), Lowercase),
+ term([Prefix|S], F, Adj, none, Pad)
+ end.
+
+%% char(Char, Field, Adjust, Precision, PadChar) -> [Char].
+
+char(C, none, _Adj, none, _Pad) -> [C];
+char(C, F, _Adj, none, _Pad) -> chars(C, F);
+char(C, none, _Adj, P, _Pad) -> chars(C, P);
+char(C, F, Adj, P, Pad) when F >= P ->
+ adjust(chars(C, P), chars(Pad, F - P), Adj).
+
+%% newline(Field, Adjust, Precision, PadChar) -> [Char].
+
+newline(none, _Adj, _P, _Pad) -> "\n";
+newline(F, right, _P, _Pad) -> chars($\n, F).
+
+%%
+%% Utilities
+%%
+
+adjust(Data, [], _) -> Data;
+adjust(Data, Pad, left) -> [Data|Pad];
+adjust(Data, Pad, right) -> [Pad|Data].
+
+%% Flatten and truncate a deep list to at most N elements.
+flat_trunc(List, N) when is_integer(N), N >= 0 ->
+ flat_trunc(List, N, []).
+
+flat_trunc(L, 0, R) when is_list(L) ->
+ lists:reverse(R);
+flat_trunc([H|T], N, R) ->
+ flat_trunc(T, N-1, [H|R]);
+flat_trunc([], _, R) ->
+ lists:reverse(R).
+
+%% A deep version of string:chars/2,3
+
+chars(_C, 0) ->
+ [];
+chars(C, 1) ->
+ [C];
+chars(C, 2) ->
+ [C,C];
+chars(C, 3) ->
+ [C,C,C];
+chars(C, N) when is_integer(N), (N band 1) =:= 0 ->
+ S = chars(C, N bsr 1),
+ [S|S];
+chars(C, N) when is_integer(N) ->
+ S = chars(C, N bsr 1),
+ [C,S|S].
+
+%chars(C, N, Tail) ->
+% [chars(C, N)|Tail].
+
+%% Lowercase conversion
+
+cond_lowercase(String, true) ->
+ lowercase(String);
+cond_lowercase(String,false) ->
+ String.
+
+lowercase([H|T]) when is_integer(H), H >= $A, H =< $Z ->
+ [(H-$A+$a)|lowercase(T)];
+lowercase([H|T]) ->
+ [H|lowercase(T)];
+lowercase([]) ->
+ [].

guam-0.9.11.tar.gz/_checkouts/lager/src/lager_handler_watcher.erl Added

@@ -0,0 +1,243 @@
+%% Copyright (c) 2011-2012 Basho Technologies, Inc.  All Rights Reserved.
+%%
+%% This file is provided to you 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.
+
+%% @doc A process that does a gen_event:add_sup_handler and attempts to re-add
+%% event handlers when they exit.
+
+%% @private
+
+-module(lager_handler_watcher).
+
+-behaviour(gen_server).
+
+-include("lager.hrl").
+
+-ifdef(TEST).
+-include_lib("eunit/include/eunit.hrl").
+-export([pop_until/2]).
+-endif.
+
+%% callbacks
+-export([init/1, handle_call/3, handle_cast/2, handle_info/2, terminate/2,
+        code_change/3]).
+
+-export([start_link/3, start/3]).
+
+-record(state, {
+        module :: atom(),
+        config :: any(),
+        sink :: pid() | atom()
+    }).
+
+start_link(Sink, Module, Config) ->
+    gen_server:start_link(?MODULE, [Sink, Module, Config], []).
+
+start(Sink, Module, Config) ->
+    gen_server:start(?MODULE, [Sink, Module, Config], []).
+
+init([Sink, Module, Config]) ->
+    process_flag(trap_exit, true),
+    install_handler(Sink, Module, Config),
+    {ok, #state{sink=Sink, module=Module, config=Config}}.
+
+handle_call(_Call, _From, State) ->
+    {reply, ok, State}.
+
+handle_cast(_Request, State) ->
+    {noreply, State}.
+
+handle_info({gen_event_EXIT, Module, normal}, #state{module=Module} = State) ->
+    {stop, normal, State};
+handle_info({gen_event_EXIT, Module, shutdown}, #state{module=Module} = State) ->
+    {stop, normal, State};
+handle_info({gen_event_EXIT, Module, {'EXIT', {kill_me, [_KillerHWM, KillerReinstallAfter]}}},
+        #state{module=Module, sink=Sink, config = Config} = State) ->
+    %% Brutally kill the manager but stay alive to restore settings.
+    %%
+    %% SinkPid here means the gen_event process. Handlers *all* live inside the
+    %% same gen_event process space, so when the Pid is killed, *all* of the 
+    %% pending log messages in its mailbox will die too.
+    SinkPid = whereis(Sink),
+    unlink(SinkPid),
+    {message_queue_len, Len} = process_info(SinkPid, message_queue_len),
+    error_logger:error_msg("Killing sink ~p, current message_queue_len:~p~n", [Sink, Len]),
+    exit(SinkPid, kill),
+    _ = timer:apply_after(KillerReinstallAfter, lager_app, start_handler, [Sink, Module, Config]),
+    {stop, normal, State};
+handle_info({gen_event_EXIT, Module, Reason}, #state{module=Module,
+        config=Config, sink=Sink} = State) ->
+    case lager:log(error, self(), "Lager event handler ~p exited with reason ~s",
+        [Module, error_logger_lager_h:format_reason(Reason)]) of
+      ok ->
+        install_handler(Sink, Module, Config);
+      {error, _} ->
+        %% lager is not working, so installing a handler won't work
+        ok
+    end,
+    {noreply, State};
+handle_info(reinstall_handler, #state{module=Module, config=Config, sink=Sink} = State) ->
+    install_handler(Sink, Module, Config),
+    {noreply, State};
+handle_info({reboot, Sink}, State) ->
+    _ = lager_app:boot(Sink),
+    {noreply, State};
+handle_info(stop, State) ->
+    {stop, normal, State};
+handle_info({'EXIT', _Pid, killed}, #state{module=Module, config=Config, sink=Sink} = State) ->
+    Tmr = application:get_env(lager, killer_reinstall_after, 5000),
+    _ = timer:apply_after(Tmr, lager_app, start_handler, [Sink, Module, Config]),
+    {stop, normal, State};
+handle_info(_Info, State) ->
+    {noreply, State}.
+
+terminate(_Reason, _State) ->
+    ok.
+
+code_change(_OldVsn, State, _Extra) ->
+    {ok, State}.
+
+%% internal
+install_handler(Sink, lager_backend_throttle, Config) ->
+    %% The lager_backend_throttle needs to know to which sink it is
+    %% attached, hence this admittedly ugly workaround. Handlers are
+    %% sensitive to the structure of the configuration sent to `init',
+    %% sadly, so it's not trivial to add a configuration item to be
+    %% ignored to backends without breaking 3rd party handlers.
+    install_handler2(Sink, lager_backend_throttle, [{sink, Sink}|Config]);
+install_handler(Sink, Module, Config) ->
+    install_handler2(Sink, Module, Config).
+
+%% private
+install_handler2(Sink, Module, Config) ->
+    case gen_event:add_sup_handler(Sink, Module, Config) of
+        ok ->
+            ?INT_LOG(debug, "Lager installed handler ~p into ~p", [Module, Sink]),
+            lager:update_loglevel_config(Sink),
+            ok;
+        {error, {fatal, Reason}} ->
+            ?INT_LOG(error, "Lager fatally failed to install handler ~p into"
+                " ~p, NOT retrying: ~p", [Module, Sink, Reason]),
+            %% tell ourselves to stop
+            self() ! stop,
+            ok;
+        Error ->
+            %% try to reinstall it later
+            ?INT_LOG(error, "Lager failed to install handler ~p into"
+               " ~p, retrying later : ~p", [Module, Sink, Error]),
+            erlang:send_after(5000, self(), reinstall_handler),
+            ok
+    end.
+
+-ifdef(TEST).
+
+from_now(Seconds) ->
+    {Mega, Secs, Micro} = os:timestamp(),
+    {Mega, Secs + Seconds, Micro}.
+
+reinstall_on_initial_failure_test_() ->
+    {timeout, 60000,
+        [
+            fun() ->
+                    error_logger:tty(false),
+                    application:load(lager),
+                    application:set_env(lager, handlers, [{lager_test_backend, info}, {lager_crash_backend, [from_now(2), undefined]}]),
+                    application:set_env(lager, error_logger_redirect, false),
+                    application:unset_env(lager, crash_log),
+                    lager:start(),
+                    try
+                      {_Level, _Time, Message, _Metadata} = lager_test_backend:pop(),
+                      ?assertMatch("Lager failed to install handler lager_crash_backend into lager_event, retrying later :"++_, lists:flatten(Message)),
+                      timer:sleep(6000),
+                      lager_test_backend:flush(),
+                      ?assertEqual(0, lager_test_backend:count()),
+                      ?assert(lists:member(lager_crash_backend, gen_event:which_handlers(lager_event)))
+                    after
+                      application:stop(lager),
+                      application:stop(goldrush),
+                      error_logger:tty(true)
+                    end
+            end
+        ]
+    }.
+
+reinstall_on_runtime_failure_test_() ->
+    {timeout, 60000,
+        [
+            fun() ->
+                    error_logger:tty(false),
+                    application:load(lager),
+                    application:set_env(lager, handlers, [{lager_test_backend, info}, {lager_crash_backend, [undefined, from_now(5)]}]),
+                    application:set_env(lager, error_logger_redirect, false),
+                    application:unset_env(lager, crash_log),
+                    lager:start(),
+                    try
+                        ?assert(lists:member(lager_crash_backend, gen_event:which_handlers(lager_event))),
+                        timer:sleep(6000),
+
+                        pop_until("Lager event handler lager_crash_backend exited with reason crash", fun lists:flatten/1),
+                        pop_until("Lager failed to install handler lager_crash_backend into lager_event, retrying later",
+                                  fun(Msg) -> string:substr(lists:flatten(Msg), 1, 84) end),
+                        ?assertEqual(false, lists:member(lager_crash_backend, gen_event:which_handlers(lager_event)))
+                    after
+                       application:stop(lager),
+                       application:stop(goldrush),
+                       error_logger:tty(true)
+                   end
+            end
+        ]
+    }.
+
+reinstall_handlers_after_killer_hwm_test_() ->
+    {timeout, 60000,
+        [
+            fun() ->
+                error_logger:tty(false),
+                application:load(lager),
+                application:set_env(lager, handlers, [{lager_manager_killer, [1000, 5000]}]),
+                application:set_env(lager, error_logger_redirect, false),
+                application:set_env(lager, killer_reinstall_after, 5000),
+                application:unset_env(lager, crash_log),
+                lager:start(),
+                lager:trace_file("foo", [{foo, "bar"}], error),
+                L = length(gen_event:which_handlers(lager_event)),
+                try
+                    lager_manager_killer:kill_me(),
+                    timer:sleep(6000),
+                    ?assertEqual(L, length(gen_event:which_handlers(lager_event))),
+                    file:delete("foo")
+                after
+                    application:stop(lager),
+                    application:stop(goldrush),
+                    error_logger:tty(true)
+                end
+            end
+        ]
+    }.
+
+pop_until(String, Fun) ->
+    try_backend_pop(lager_test_backend:pop(), String, Fun).
+
+try_backend_pop(undefined, String, _Fun) ->
+    throw("Not found: " ++ String);
+try_backend_pop({_Severity, _Date, Msg, _Metadata}, String, Fun) ->
+    case Fun(Msg) of
+        String ->
+            ok;
+        _ ->
+            try_backend_pop(lager_test_backend:pop(), String, Fun)
+    end.
+
+-endif.

guam-0.9.11.tar.gz/_checkouts/lager/src/lager_handler_watcher_sup.erl Added

@@ -0,0 +1,39 @@
+%% Copyright (c) 2011-2012 Basho Technologies, Inc.  All Rights Reserved.
+%%
+%% This file is provided to you 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.
+
+%% @doc A supervisor for monitoring lager_handler_watcher processes.
+
+%% @private
+
+-module(lager_handler_watcher_sup).
+
+-behaviour(supervisor).
+
+%% API
+-export([start_link/0]).
+
+%% Callbacks
+-export([init/1]).
+
+start_link() ->
+    supervisor:start_link({local, ?MODULE}, ?MODULE, []).
+
+init([]) ->
+    {ok, {{simple_one_for_one, 10, 60},
+            [
+                {lager_handler_watcher, {lager_handler_watcher, start_link, []},
+                        temporary, 5000, worker, [lager_handler_watcher]}
+                ]}}.

guam-0.9.11.tar.gz/_checkouts/lager/src/lager_manager_killer.erl Added

@@ -0,0 +1,53 @@
+-module(lager_manager_killer).
+-author("Sungjin Park <jinni.park@gmail.com>").
+-behavior(gen_event).
+
+-export([init/1, handle_event/2, handle_call/2, handle_info/2, terminate/2, code_change/3]).
+
+-export([kill_me/0]).
+
+-include("lager.hrl").
+
+-record(state, {
+ killer_hwm :: non_neg_integer(),
+ killer_reinstall_after :: non_neg_integer()
+ }).
+
+kill_me() ->
+ gen_event:call(lager_event, ?MODULE, kill_self).
+
+init([KillerHWM, KillerReinstallAfter]) ->
+ {ok, #state{killer_hwm=KillerHWM, killer_reinstall_after=KillerReinstallAfter}}.
+
+handle_call(get_loglevel, State) ->
+ {ok, {mask, ?LOG_NONE}, State};
+handle_call({set_loglevel, _Level}, State) ->
+ {ok, ok, State};
+handle_call(get_settings, State = #state{killer_hwm=KillerHWM, killer_reinstall_after=KillerReinstallAfter}) ->
+ {ok, [KillerHWM, KillerReinstallAfter], State};
+handle_call(kill_self, #state{killer_hwm=KillerHWM, killer_reinstall_after=KillerReinstallAfter}) ->
+ exit({kill_me, [KillerHWM, KillerReinstallAfter]});
+handle_call(_Request, State) ->
+ {ok, ok, State}.
+%% It's not the best idea in the world to check the queue length for every
+%% log message. We can make this operation work on a poll timer in the
+%% future.
+handle_event({log, _Message}, State = #state{killer_hwm=KillerHWM, killer_reinstall_after=KillerReinstallAfter}) ->
+ {message_queue_len, Len} = process_info(self(), message_queue_len),
+ case Len > KillerHWM of
+ true ->
+ exit({kill_me, [KillerHWM, KillerReinstallAfter]});
+ _ ->
+ {ok, State}
+ end;
+handle_event(_Event, State) ->
+ {ok, State}.
+
+handle_info(_Info, State) ->
+ {ok, State}.
+
+terminate(_Reason, _State) ->
+ ok.
+
+code_change(_OldVsn, State, _Extra) ->
+ {ok, State}.

guam-0.9.11.tar.gz/_checkouts/lager/src/lager_msg.erl Added

@@ -0,0 +1,64 @@
+-module(lager_msg).
+
+-export([new/4, new/5]).
+-export([message/1]).
+-export([timestamp/1]).
+-export([datetime/1]).
+-export([severity/1]).
+-export([severity_as_int/1]).
+-export([metadata/1]).
+-export([destinations/1]).
+
+-record(lager_msg,{
+        destinations :: list(),
+        metadata :: [tuple()],
+        severity :: lager:log_level(),
+        datetime :: {string(), string()},
+        timestamp :: erlang:timestamp(),
+        message :: list()
+    }).
+
+-opaque lager_msg() :: #lager_msg{}.
+-export_type([lager_msg/0]).
+
+%% create with provided timestamp, handy for testing mostly
+-spec new(list(), erlang:timestamp(), lager:log_level(), [tuple()], list()) -> lager_msg().
+new(Msg, Timestamp, Severity, Metadata, Destinations) ->
+    {Date, Time} = lager_util:format_time(lager_util:maybe_utc(lager_util:localtime_ms(Timestamp))),
+    #lager_msg{message=Msg, datetime={Date, Time}, timestamp=Timestamp, severity=Severity,
+        metadata=Metadata, destinations=Destinations}.
+
+-spec new(list(), lager:log_level(), [tuple()], list()) -> lager_msg().
+new(Msg, Severity, Metadata, Destinations) ->
+    Now = os:timestamp(),
+    new(Msg, Now, Severity, Metadata, Destinations).
+
+-spec message(lager_msg()) -> list().
+message(Msg) ->
+    Msg#lager_msg.message.
+
+-spec timestamp(lager_msg()) -> erlang:timestamp().
+timestamp(Msg) ->
+    Msg#lager_msg.timestamp.
+
+-spec datetime(lager_msg()) -> {string(), string()}.
+datetime(Msg) ->
+    Msg#lager_msg.datetime.
+
+-spec severity(lager_msg()) -> lager:log_level().
+severity(Msg) ->
+    Msg#lager_msg.severity.
+
+-spec severity_as_int(lager_msg()) -> lager:log_level_number().
+severity_as_int(Msg) ->
+    lager_util:level_to_num(Msg#lager_msg.severity).
+
+-spec metadata(lager_msg()) -> [tuple()].
+metadata(Msg) ->
+    Msg#lager_msg.metadata.
+
+-spec destinations(lager_msg()) -> list().
+destinations(Msg) ->
+    Msg#lager_msg.destinations.
+
+

guam-0.9.11.tar.gz/_checkouts/lager/src/lager_rotator_behaviour.erl Added

guam-0.9.11.tar.gz/_checkouts/lager/src/lager_rotator_default.erl Added

@@ -0,0 +1,197 @@
+-module(lager_rotator_default).
+
+-include_lib("kernel/include/file.hrl").
+
+-behaviour(lager_rotator_behaviour).
+
+-export([
+ create_logfile/2, open_logfile/2, ensure_logfile/5, rotate_logfile/2
+]).
+
+-ifdef(TEST).
+-include_lib("eunit/include/eunit.hrl").
+-endif.
+
+create_logfile(Name, Buffer) ->
+ open_logfile(Name, Buffer).
+
+open_logfile(Name, Buffer) ->
+ case filelib:ensure_dir(Name) of
+ ok ->
+ Options = [append, raw] ++
+ case Buffer of
+ {Size0, Interval} when is_integer(Interval), Interval >= 0, is_integer(Size0), Size0 >= 0 ->
+ [{delayed_write, Size0, Interval}];
+ _ -> []
+ end,
+ case file:open(Name, Options) of
+ {ok, FD} ->
+ case file:read_file_info(Name, [raw]) of
+ {ok, FInfo0} ->
+ Inode = FInfo0#file_info.inode,
+ {ok, Ctime} = maybe_update_ctime(Name, FInfo0),
+ Size1 = FInfo0#file_info.size,
+ {ok, {FD, Inode, Ctime, Size1}};
+ X -> X
+ end;
+ Y -> Y
+ end;
+ Z -> Z
+ end.
+
+ensure_logfile(Name, undefined, _Inode, _Ctime, Buffer) ->
+ open_logfile(Name, Buffer);
+ensure_logfile(Name, FD, Inode0, Ctime0, Buffer) ->
+ case lager_util:has_file_changed(Name, Inode0, Ctime0) of
+ {true, _FInfo} ->
+ reopen_logfile(Name, FD, Buffer);
+ {_, FInfo} ->
+ {ok, {FD, Inode0, Ctime0, FInfo#file_info.size}}
+ end.
+
+reopen_logfile(Name, FD0, Buffer) ->
+ %% Flush and close any file handles.
+ %% delayed write can cause file:close not to do a close
+ _ = file:datasync(FD0),
+ _ = file:close(FD0),
+ _ = file:close(FD0),
+ case open_logfile(Name, Buffer) of
+ {ok, {_FD1, _Inode, _Size, _Ctime}=FileInfo} ->
+ %% inode changed, file was probably moved and
+ %% recreated
+ {ok, FileInfo};
+ Error ->
+ Error
+ end.
+
+%% renames failing are OK
+rotate_logfile(File, 0) ->
+ %% open the file in write-only mode to truncate/create it
+ case file:open(File, [write]) of
+ {ok, FD} ->
+ _ = file:close(FD),
+ _ = file:close(FD),
+ {ok, _Ctime} = maybe_update_ctime(File),
+ ok;
+ Error ->
+ Error
+ end;
+rotate_logfile(File0, 1) ->
+ File1 = File0 ++ ".0",
+ _ = file:rename(File0, File1),
+ rotate_logfile(File0, 0);
+rotate_logfile(File0, Count) ->
+ File1 = File0 ++ "." ++ integer_to_list(Count - 2),
+ File2 = File0 ++ "." ++ integer_to_list(Count - 1),
+ _ = file:rename(File1, File2),
+ rotate_logfile(File0, Count - 1).
+
+maybe_update_ctime(Name) ->
+ case file:read_file_info(Name, [raw]) of
+ {ok, FInfo} ->
+ maybe_update_ctime(Name, FInfo);
+ _ ->
+ {ok, calendar:local_time()}
+ end.
+
+maybe_update_ctime(Name, FInfo) ->
+ {OsType, _} = os:type(),
+ do_update_ctime(OsType, Name, FInfo).
+
+do_update_ctime(win32, Name, FInfo0) ->
+ % Note: we force the creation time to be the current time.
+ % On win32 this may prevent the ctime from being updated:
+ % https://stackoverflow.com/q/8804342/1466825
+ NewCtime = calendar:local_time(),
+ FInfo1 = FInfo0#file_info{ctime = NewCtime},
+ ok = file:write_file_info(Name, FInfo1, [raw]),
+ {ok, NewCtime};
+do_update_ctime(_, _Name, FInfo) ->
+ {ok, FInfo#file_info.ctime}.
+
+-ifdef(TEST).
+
+rotate_file_test() ->
+ RotCount = 10,
+ {ok, TestDir} = lager_util:create_test_dir(),
+ TestLog = filename:join(TestDir, "rotation.log"),
+ Outer = fun(N) ->
+ ?assertEqual(ok, lager_util:safe_write_file(TestLog, erlang:integer_to_list(N))),
+ Inner = fun(M) ->
+ File = lists:flatten([TestLog, $., erlang:integer_to_list(M)]),
+ ?assert(filelib:is_regular(File)),
+ %% check the expected value is in the file
+ Number = erlang:list_to_binary(integer_to_list(N - M - 1)),
+ ?assertEqual({ok, Number}, file:read_file(File))
+ end,
+ Count = erlang:min(N, RotCount),
+ % The first time through, Count == 0, so the sequence is empty,
+ % effectively skipping the inner loop so a rotation can occur that
+ % creates the file that Inner looks for.
+ % Don't shoot the messenger, it was worse before this refactoring.
+ lists:foreach(Inner, lists:seq(0, Count-1)),
+ rotate_logfile(TestLog, RotCount)
+ end,
+ lists:foreach(Outer, lists:seq(0, (RotCount * 2))),
+ lager_util:delete_test_dir(TestDir).
+
+rotate_file_zero_count_test() ->
+ %% Test that a rotation count of 0 simply truncates the file
+ {ok, TestDir} = lager_util:create_test_dir(),
+ TestLog = filename:join(TestDir, "rotation.log"),
+ ?assertMatch(ok, rotate_logfile(TestLog, 0)),
+ ?assertNot(filelib:is_regular(TestLog ++ ".0")),
+ ?assertEqual(true, filelib:is_regular(TestLog)),
+ ?assertEqual(1, length(filelib:wildcard(TestLog++"*"))),
+ %% assert the new file is 0 size:
+ case file:read_file_info(TestLog, [raw]) of
+ {ok, FInfo} ->
+ ?assertEqual(0, FInfo#file_info.size);
+ _ ->
+ ?assert(false)
+ end,
+ lager_util:delete_test_dir(TestDir).
+
+rotate_file_fail_test() ->
+ {ok, TestDir} = lager_util:create_test_dir(),
+ TestLog = filename:join(TestDir, "rotation.log"),
+
+ %% set known permissions on it
+ ok = lager_util:set_dir_permissions("u+rwx", TestDir),
+
+ %% write a file
+ ?assertEqual(ok, lager_util:safe_write_file(TestLog, "hello")),
+
+ case os:type() of
+ {win32, _} -> ok;
+ _ ->
+ %% hose up the permissions
+ ok = lager_util:set_dir_permissions("u-w", TestDir),
+ ?assertMatch({error, _}, rotate_logfile(TestLog, 10))
+ end,
+
+ %% check we still only have one file, rotation.log
+ ?assertEqual([TestLog], filelib:wildcard(TestLog++"*")),
+ ?assert(filelib:is_regular(TestLog)),
+
+ %% fix the permissions
+ ok = lager_util:set_dir_permissions("u+w", TestDir),
+
+ ?assertMatch(ok, rotate_logfile(TestLog, 10)),
+ ?assert(filelib:is_regular(TestLog ++ ".0")),
+ ?assertEqual(true, filelib:is_regular(TestLog)),
+ ?assertEqual(2, length(filelib:wildcard(TestLog++"*"))),
+
+ %% assert the new file is 0 size:
+ case file:read_file_info(TestLog, [raw]) of
+ {ok, FInfo} ->
+ ?assertEqual(0, FInfo#file_info.size);
+ _ ->
+ ?assert(false)
+ end,
+
+ %% check that the .0 file now has the contents "hello"
+ ?assertEqual({ok, <<"hello">>}, file:read_file(TestLog++".0")),
+ lager_util:delete_test_dir(TestDir).
+
+-endif.

guam-0.9.11.tar.gz/_checkouts/lager/src/lager_stdlib.erl Added

@@ -0,0 +1,502 @@
+%%
+%% %CopyrightBegin%
+%% 
+%% Copyright Ericsson AB 1996-2009. All Rights Reserved.
+%% 
+%% The contents of this file are subject to the Erlang Public License,
+%% Version 1.1, (the "License"); you may not use this file except in
+%% compliance with the License. You should have received a copy of the
+%% Erlang Public License along with this software. If not, it can be
+%% retrieved online at http://www.erlang.org/.
+%% 
+%% Software distributed under the License is distributed on an "AS IS"
+%% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
+%% the License for the specific language governing rights and limitations
+%% under the License.
+%% 
+%% %CopyrightEnd%
+%%
+
+%% @doc Functions from Erlang OTP distribution that are really useful
+%% but aren't exported.
+%%
+%% All functions in this module are covered by the Erlang/OTP source
+%% distribution's license, the Erlang Public License. See
+%% http://www.erlang.org/ for full details.
+
+-module(lager_stdlib).
+
+-export([string_p/1]).
+-export([write_time/2, maybe_utc/1]).
+-export([is_my_error_report/1, is_my_info_report/1]).
+-export([sup_get/2]).
+-export([proc_lib_format/2]).
+
+
+%% from error_logger_file_h
+string_p([]) ->
+ false;
+string_p(Term) ->
+ string_p1(Term).
+
+string_p1([H|T]) when is_integer(H), H >= $\s, H < 256 ->
+ string_p1(T);
+string_p1([$\n|T]) -> string_p1(T);
+string_p1([$\r|T]) -> string_p1(T);
+string_p1([$\t|T]) -> string_p1(T);
+string_p1([$\v|T]) -> string_p1(T);
+string_p1([$\b|T]) -> string_p1(T);
+string_p1([$\f|T]) -> string_p1(T);
+string_p1([$\e|T]) -> string_p1(T);
+string_p1([H|T]) when is_list(H) ->
+ case string_p1(H) of
+ true -> string_p1(T);
+ _ -> false
+ end;
+string_p1([]) -> true;
+string_p1(_) -> false.
+
+%% From calendar
+-type year1970() :: 1970..10000. % should probably be 1970..
+-type month() :: 1..12.
+-type day() :: 1..31.
+-type hour() :: 0..23.
+-type minute() :: 0..59.
+-type second() :: 0..59.
+-type t_time() :: {hour(),minute(),second()}.
+-type t_datetime1970() :: {{year1970(),month(),day()},t_time()}.
+
+%% From OTP stdlib's error_logger_tty_h.erl ... These functions aren't
+%% exported.
+-spec write_time({utc, t_datetime1970()} | t_datetime1970(), string()) -> string().
+write_time({utc,{{Y,Mo,D},{H,Mi,S}}},Type) ->
+ io_lib:format("~n=~s==== ~p-~s-~p::~s:~s:~s UTC ===~n",
+ [Type,D,month(Mo),Y,t(H),t(Mi),t(S)]);
+write_time({{Y,Mo,D},{H,Mi,S}},Type) ->
+ io_lib:format("~n=~s==== ~p-~s-~p::~s:~s:~s ===~n",
+ [Type,D,month(Mo),Y,t(H),t(Mi),t(S)]).
+
+-spec maybe_utc(t_datetime1970()) -> {utc, t_datetime1970()} | t_datetime1970().
+maybe_utc(Time) ->
+ UTC = case application:get_env(sasl, utc_log) of
+ {ok, Val} ->
+ Val;
+ undefined ->
+ %% Backwards compatible:
+ application:get_env(stdlib, utc_log, false)
+ end,
+ if
+ UTC =:= true ->
+ UTCTime = case calendar:local_time_to_universal_time_dst(Time) of
+ [] -> calendar:local_time();
+ [T0|_] -> T0
+ end,
+ {utc, UTCTime};
+ true -> 
+ Time
+ end.
+
+t(X) when is_integer(X) ->
+ t1(integer_to_list(X));
+t(_) ->
+ "".
+t1([X]) -> [$0,X];
+t1(X) -> X.
+
+month(1) -> "Jan";
+month(2) -> "Feb";
+month(3) -> "Mar";
+month(4) -> "Apr";
+month(5) -> "May";
+month(6) -> "Jun";
+month(7) -> "Jul";
+month(8) -> "Aug";
+month(9) -> "Sep";
+month(10) -> "Oct";
+month(11) -> "Nov";
+month(12) -> "Dec".
+
+%% From OTP sasl's sasl_report.erl ... These functions aren't
+%% exported.
+-spec is_my_error_report(atom()) -> boolean().
+is_my_error_report(supervisor_report) -> true;
+is_my_error_report(crash_report) -> true;
+is_my_error_report(_) -> false.
+
+-spec is_my_info_report(atom()) -> boolean().
+is_my_info_report(progress) -> true;
+is_my_info_report(_) -> false.
+
+-spec sup_get(term(), [proplists:property()]) -> term().
+sup_get(Tag, Report) ->
+ case lists:keysearch(Tag, 1, Report) of
+ {value, {_, Value}} ->
+ Value;
+ _ ->
+ ""
+ end.
+
+%% From OTP stdlib's proc_lib.erl ... These functions aren't exported.
+-spec proc_lib_format([term()], pos_integer()) -> string().
+proc_lib_format([OwnReport,LinkReport], FmtMaxBytes) ->
+ OwnFormat = format_report(OwnReport, FmtMaxBytes),
+ LinkFormat = format_report(LinkReport, FmtMaxBytes),
+ %% io_lib:format here is OK because we're limiting max length elsewhere.
+ Str = io_lib:format(" crasher:~n~s neighbours:~n~s",[OwnFormat,LinkFormat]),
+ lists:flatten(Str).
+
+format_report(Rep, FmtMaxBytes) when is_list(Rep) ->
+ format_rep(Rep, FmtMaxBytes);
+format_report(Rep, FmtMaxBytes) ->
+ {Str, _} = lager_trunc_io:print(Rep, FmtMaxBytes),
+ io_lib:format("~p~n", [Str]).
+
+format_rep([{initial_call,InitialCall}|Rep], FmtMaxBytes) ->
+ [format_mfa(InitialCall, FmtMaxBytes)|format_rep(Rep, FmtMaxBytes)];
+format_rep([{error_info,{Class,Reason,StackTrace}}|Rep], FmtMaxBytes) ->
+ [format_exception(Class, Reason, StackTrace, FmtMaxBytes)|format_rep(Rep, FmtMaxBytes)];
+format_rep([{Tag,Data}|Rep], FmtMaxBytes) ->
+ [format_tag(Tag, Data, FmtMaxBytes)|format_rep(Rep, FmtMaxBytes)];
+format_rep(_, _S) ->
+ [].
+
+format_exception(Class, Reason, StackTrace, FmtMaxBytes) ->
+ PF = pp_fun(FmtMaxBytes),
+ StackFun = fun(M, _F, _A) -> (M =:= erl_eval) or (M =:= ?MODULE) end,
+ %% EI = " exception: ",
+ EI = " ",
+ [EI, lib_format_exception(1+length(EI), Class, Reason, 
+ StackTrace, StackFun, PF), "\n"].
+
+format_mfa({M,F,Args}=StartF, FmtMaxBytes) ->
+ try
+ A = length(Args),
+ [" initial call: ",atom_to_list(M),$:,atom_to_list(F),$/,
+ integer_to_list(A),"\n"]
+ catch
+ error:_ ->
+ format_tag(initial_call, StartF, FmtMaxBytes)
+ end.
+
+pp_fun(FmtMaxBytes) ->
+ fun(Term, _I) -> 
+ {Str, _} = lager_trunc_io:print(Term, FmtMaxBytes),
+ io_lib:format("~s", [Str]) 
+ end.
+
+format_tag(Tag, Data, FmtMaxBytes) ->
+ {Str, _} = lager_trunc_io:print(Data, FmtMaxBytes),
+ io_lib:format(" ~p: ~s~n", [Tag, Str]).
+
+%% From OTP stdlib's lib.erl ... These functions aren't exported.
+
+lib_format_exception(I, Class, Reason, StackTrace, StackFun, FormatFun) 
+ when is_integer(I), I >= 1, is_function(StackFun, 3), 
+ is_function(FormatFun, 2) ->
+ Str = n_spaces(I-1),
+ {Term,Trace1,Trace} = analyze_exception(Class, Reason, StackTrace),
+ Expl0 = explain_reason(Term, Class, Trace1, FormatFun, Str),
+ Expl = io_lib:fwrite(<<"~s~s">>, [exited(Class), Expl0]),
+ case format_stacktrace1(Str, Trace, FormatFun, StackFun) of
+ [] -> Expl;
+ Stack -> [Expl, $\n, Stack]
+ end.
+
+analyze_exception(error, Term, Stack) ->
+ case {is_stacktrace(Stack), Stack, Term} of
+ {true, [{_M,_F,As}=MFA|MFAs], function_clause} when is_list(As) -> 
+ {Term,[MFA],MFAs};
+ {true, [{shell,F,A}], function_clause} when is_integer(A) ->
+ {Term, [{F,A}], []};
+ {true, [{_M,_F,_AorAs}=MFA|MFAs], undef} ->
+ {Term,[MFA],MFAs};
+ {true, _, _} ->
+ {Term,[],Stack};
+ {false, _, _} ->
+ {{Term,Stack},[],[]}
+ end;
+analyze_exception(_Class, Term, Stack) ->
+ case is_stacktrace(Stack) of
+ true ->
+ {Term,[],Stack};
+ false ->
+ {{Term,Stack},[],[]}
+ end.
+
+is_stacktrace([]) ->
+ true;
+is_stacktrace([{M,F,A}|Fs]) when is_atom(M), is_atom(F), is_integer(A) ->
+ is_stacktrace(Fs);
+is_stacktrace([{M,F,As}|Fs]) when is_atom(M), is_atom(F), length(As) >= 0 ->
+ is_stacktrace(Fs);
+is_stacktrace(_) ->
+ false.
+
+%% ERTS exit codes (some of them are also returned by erl_eval):
+explain_reason(badarg, error, [], _PF, _Str) ->
+ <<"bad argument">>;
+explain_reason({badarg,V}, error=Cl, [], PF, Str) -> % orelse, andalso
+ format_value(V, <<"bad argument: ">>, Cl, PF, Str);
+explain_reason(badarith, error, [], _PF, _Str) ->
+ <<"bad argument in an arithmetic expression">>;
+explain_reason({badarity,{Fun,As}}, error, [], _PF, _Str) 
+ when is_function(Fun) ->
+ %% Only the arity is displayed, not the arguments As.
+ io_lib:fwrite(<<"~s called with ~s">>, 
+ [format_fun(Fun), argss(length(As))]);
+explain_reason({badfun,Term}, error=Cl, [], PF, Str) ->
+ format_value(Term, <<"bad function ">>, Cl, PF, Str);
+explain_reason({badmatch,Term}, error=Cl, [], PF, Str) ->
+ format_value(Term, <<"no match of right hand side value ">>, Cl, PF, Str);
+explain_reason({case_clause,V}, error=Cl, [], PF, Str) ->
+ %% "there is no case clause with a true guard sequence and a
+ %% pattern matching..."
+ format_value(V, <<"no case clause matching ">>, Cl, PF, Str);
+explain_reason(function_clause, error, [{F,A}], _PF, _Str) ->
+ %% Shell commands
+ FAs = io_lib:fwrite(<<"~w/~w">>, [F, A]),
+ [<<"no function clause matching call to ">> | FAs];
+explain_reason(function_clause, error=Cl, [{M,F,As}], PF, Str) ->
+ String = <<"no function clause matching ">>,
+ format_errstr_call(String, Cl, {M,F}, As, PF, Str);
+explain_reason(if_clause, error, [], _PF, _Str) ->
+ <<"no true branch found when evaluating an if expression">>;
+explain_reason(noproc, error, [], _PF, _Str) ->
+ <<"no such process or port">>;
+explain_reason(notalive, error, [], _PF, _Str) ->
+ <<"the node cannot be part of a distributed system">>;
+explain_reason(system_limit, error, [], _PF, _Str) ->
+ <<"a system limit has been reached">>;
+explain_reason(timeout_value, error, [], _PF, _Str) ->
+ <<"bad receive timeout value">>;
+explain_reason({try_clause,V}, error=Cl, [], PF, Str) ->
+ %% "there is no try clause with a true guard sequence and a
+ %% pattern matching..."
+ format_value(V, <<"no try clause matching ">>, Cl, PF, Str);
+explain_reason(undef, error, [{M,F,A}], _PF, _Str) ->
+ %% Only the arity is displayed, not the arguments, if there are any.
+ io_lib:fwrite(<<"undefined function ~s">>, 
+ [mfa_to_string(M, F, n_args(A))]);
+explain_reason({shell_undef,F,A}, error, [], _PF, _Str) ->
+ %% Give nicer reports for undefined shell functions
+ %% (but not when the user actively calls shell_default:F(...)).
+ io_lib:fwrite(<<"undefined shell command ~s/~w">>, [F, n_args(A)]);
+%% Exit codes returned by erl_eval only:
+explain_reason({argument_limit,_Fun}, error, [], _PF, _Str) ->
+ io_lib:fwrite(<<"limit of number of arguments to interpreted function"
+ " exceeded">>, []);
+explain_reason({bad_filter,V}, error=Cl, [], PF, Str) ->
+ format_value(V, <<"bad filter ">>, Cl, PF, Str);
+explain_reason({bad_generator,V}, error=Cl, [], PF, Str) ->
+ format_value(V, <<"bad generator ">>, Cl, PF, Str);
+explain_reason({unbound,V}, error, [], _PF, _Str) ->
+ io_lib:fwrite(<<"variable ~w is unbound">>, [V]);
+%% Exit codes local to the shell module (restricted shell):
+explain_reason({restricted_shell_bad_return, V}, exit=Cl, [], PF, Str) ->
+ String = <<"restricted shell module returned bad value ">>,
+ format_value(V, String, Cl, PF, Str);
+explain_reason({restricted_shell_disallowed,{ForMF,As}}, 
+ exit=Cl, [], PF, Str) ->
+ %% ForMF can be a fun, but not a shell fun.
+ String = <<"restricted shell does not allow ">>,
+ format_errstr_call(String, Cl, ForMF, As, PF, Str);
+explain_reason(restricted_shell_started, exit, [], _PF, _Str) ->
+ <<"restricted shell starts now">>;
+explain_reason(restricted_shell_stopped, exit, [], _PF, _Str) ->
+ <<"restricted shell stopped">>;
+%% Other exit code:
+explain_reason(Reason, Class, [], PF, Str) ->
+ PF(Reason, (iolist_size(Str)+1) + exited_size(Class)).
+
+n_spaces(N) ->
+ lists:duplicate(N, $\s).
+
+exited_size(Class) ->
+ iolist_size(exited(Class)).
+
+exited(error) ->
+ <<"exception error: ">>;
+exited(exit) ->
+ <<"exception exit: ">>;
+exited(throw) ->
+ <<"exception throw: ">>.
+
+format_stacktrace1(S0, Stack0, PF, SF) ->
+ Stack1 = lists:dropwhile(fun({M,F,A}) -> SF(M, F, A)
+ end, lists:reverse(Stack0)),
+ S = [" " | S0],
+ Stack = lists:reverse(Stack1),
+ format_stacktrace2(S, Stack, 1, PF).
+
+format_stacktrace2(S, [{M,F,A}|Fs], N, PF) when is_integer(A) ->
+ [io_lib:fwrite(<<"~s~s ~s">>, 
+ [sep(N, S), origin(N, M, F, A), mfa_to_string(M, F, A)])
+ | format_stacktrace2(S, Fs, N + 1, PF)];
+format_stacktrace2(S, [{M,F,As}|Fs], N, PF) when is_list(As) ->
+ A = length(As),
+ CalledAs = [S,<<" called as ">>],
+ C = format_call("", CalledAs, {M,F}, As, PF),
+ [io_lib:fwrite(<<"~s~s ~s\n~s~s">>,
+ [sep(N, S), origin(N, M, F, A), mfa_to_string(M, F, A),
+ CalledAs, C])
+ | format_stacktrace2(S, Fs, N + 1, PF)];
+format_stacktrace2(_S, [], _N, _PF) ->
+ "".
+
+argss(0) ->
+ <<"no arguments">>;
+argss(1) ->
+ <<"one argument">>;
+argss(2) ->
+ <<"two arguments">>;
+argss(I) ->
+ io_lib:fwrite(<<"~w arguments">>, [I]).
+
+format_value(V, ErrStr, Class, PF, Str) ->
+ Pre1Sz = exited_size(Class),
+ Str1 = PF(V, Pre1Sz + iolist_size([Str, ErrStr])+1),
+ [ErrStr | case count_nl(Str1) of
+ N1 when N1 > 1 ->
+ Str2 = PF(V, iolist_size(Str) + 1 + Pre1Sz),
+ case count_nl(Str2) < N1 of
+ true ->
+ [$\n, Str, n_spaces(Pre1Sz) | Str2];
+ false ->
+ Str1
+ end;
+ _ ->
+ Str1
+ end].
+
+format_fun(Fun) when is_function(Fun) ->
+ {module, M} = erlang:fun_info(Fun, module),
+ {name, F} = erlang:fun_info(Fun, name),
+ {arity, A} = erlang:fun_info(Fun, arity),
+ case erlang:fun_info(Fun, type) of
+ {type, local} when F =:= "" ->
+ io_lib:fwrite(<<"~w">>, [Fun]);
+ {type, local} when M =:= erl_eval ->
+ io_lib:fwrite(<<"interpreted function with arity ~w">>, [A]);
+ {type, local} ->
+ mfa_to_string(M, F, A);
+ {type, external} ->
+ mfa_to_string(M, F, A)
+ end.
+
+format_errstr_call(ErrStr, Class, ForMForFun, As, PF, Pre0) ->
+ Pre1 = [Pre0 | n_spaces(exited_size(Class))],
+ format_call(ErrStr, Pre1, ForMForFun, As, PF).
+
+format_call(ErrStr, Pre1, ForMForFun, As, PF) ->
+ Arity = length(As),
+ [ErrStr |
+ case is_op(ForMForFun, Arity) of
+ {yes,Op} -> 
+ format_op(ErrStr, Pre1, Op, As, PF);
+ no ->
+ MFs = mf_to_string(ForMForFun, Arity),
+ I1 = iolist_size([Pre1,ErrStr|MFs]),
+ S1 = pp_arguments(PF, As, I1),
+ S2 = pp_arguments(PF, As, iolist_size([Pre1|MFs])),
+ Long = count_nl(pp_arguments(PF, [a2345,b2345], I1)) > 0,
+ case Long or (count_nl(S2) < count_nl(S1)) of
+ true ->
+ [$\n, Pre1, MFs, S2];
+ false ->
+ [MFs, S1]
+ end
+ end].
+
+mfa_to_string(M, F, A) ->
+ io_lib:fwrite(<<"~s/~w">>, [mf_to_string({M, F}, A), A]).
+
+mf_to_string({M, F}, A) ->
+ case erl_internal:bif(M, F, A) of
+ true ->
+ io_lib:fwrite(<<"~w">>, [F]);
+ false ->
+ case is_op({M, F}, A) of
+ {yes, '/'} ->
+ io_lib:fwrite(<<"~w">>, [F]);
+ {yes, F} ->
+ atom_to_list(F);
+ no ->
+ io_lib:fwrite(<<"~w:~w">>, [M, F])
+ end
+ end;
+mf_to_string(Fun, _A) when is_function(Fun) ->
+ format_fun(Fun);
+mf_to_string(F, _A) ->
+ io_lib:fwrite(<<"~w">>, [F]).
+
+n_args(A) when is_integer(A) ->
+ A;
+n_args(As) when is_list(As) ->
+ length(As).
+
+origin(1, M, F, A) ->
+ case is_op({M, F}, n_args(A)) of
+ {yes, F} -> <<"in operator ">>;
+ no -> <<"in function ">>
+ end;
+origin(_N, _M, _F, _A) ->
+ <<"in call from">>.
+
+sep(1, S) -> S;
+sep(_, S) -> [$\n | S].
+
+count_nl([E | Es]) ->
+ count_nl(E) + count_nl(Es);
+count_nl($\n) ->
+ 1;
+count_nl(Bin) when is_binary(Bin) ->
+ count_nl(binary_to_list(Bin));
+count_nl(_) ->
+ 0.
+
+is_op(ForMForFun, A) ->
+ try 
+ {erlang,F} = ForMForFun,
+ _ = erl_internal:op_type(F, A), 
+ {yes,F}
+ catch error:_ -> no
+ end.
+
+format_op(ErrStr, Pre, Op, [A1, A2], PF) ->
+ I1 = iolist_size([ErrStr,Pre]),
+ S1 = PF(A1, I1+1),
+ S2 = PF(A2, I1+1),
+ OpS = atom_to_list(Op),
+ Pre1 = [$\n | n_spaces(I1)],
+ case count_nl(S1) > 0 of
+ true -> 
+ [S1,Pre1,OpS,Pre1|S2];
+ false ->
+ OpS2 = io_lib:fwrite(<<" ~s ">>, [Op]),
+ S2_2 = PF(A2, iolist_size([ErrStr,Pre,S1|OpS2])+1),
+ case count_nl(S2) < count_nl(S2_2) of
+ true ->
+ [S1,Pre1,OpS,Pre1|S2];
+ false ->
+ [S1,OpS2|S2_2]
+ end
+ end.
+
+pp_arguments(PF, As, I) ->
+ case {As, io_lib:printable_list(As)} of
+ {[Int | T], true} ->
+ L = integer_to_list(Int),
+ Ll = length(L),
+ A = list_to_atom(lists:duplicate(Ll, $a)),
+ S0 = binary_to_list(iolist_to_binary(PF([A | T], I+1))),
+ brackets_to_parens([$[,L,string:sub_string(S0, 2+Ll)]);
+ _ -> 
+ brackets_to_parens(PF(As, I+1))
+ end.
+
+brackets_to_parens(S) ->
+ B = iolist_to_binary(S),
+ Sz = byte_size(B) - 2,
+ <<$[,R:Sz/binary,$]>> = B,
+ [$(,R,$)].
+

guam-0.9.11.tar.gz/_checkouts/lager/src/lager_sup.erl Added

@@ -0,0 +1,92 @@
+%% Copyright (c) 2011-2012 Basho Technologies, Inc.  All Rights Reserved.
+%%
+%% This file is provided to you 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.
+
+%% @doc Lager's top level supervisor.
+
+%% @private
+
+-module(lager_sup).
+
+-behaviour(supervisor).
+
+%% API
+-export([start_link/0]).
+
+%% Callbacks
+-export([init/1]).
+
+start_link() ->
+    supervisor:start_link({local, ?MODULE}, ?MODULE, []).
+
+init([]) ->
+    %% set up the config, is safe even during relups
+    lager_config:new(),
+    %% TODO:
+    %% Always start lager_event as the default and make sure that
+    %% other gen_event stuff can start up as needed
+    %%
+    %% Maybe a new API to handle the sink and its policy?
+    Children = [
+        {lager, {gen_event, start_link, [{local, lager_event}]},
+            permanent, 5000, worker, dynamic},
+        {lager_handler_watcher_sup, {lager_handler_watcher_sup, start_link, []},
+            permanent, 5000, supervisor, [lager_handler_watcher_sup]}],
+
+    CrashLog = decide_crash_log(application:get_env(lager, crash_log, false)),
+
+    {ok, {{one_for_one, 10, 60},
+          Children ++ CrashLog
+         }}.
+
+validate_positive({ok, Val}, _Default) when is_integer(Val) andalso Val >= 0 ->
+    Val;
+validate_positive(_Val, Default) ->
+    Default.
+
+determine_rotation_date({ok, ""}) ->
+    undefined;
+determine_rotation_date({ok, Val3}) ->
+    case lager_util:parse_rotation_date_spec(Val3) of
+        {ok, Spec} -> Spec;
+        {error, _} ->
+            error_logger:error_msg("Invalid date spec for "
+                                   "crash log ~p~n", [Val3]),
+            undefined
+    end;
+determine_rotation_date(_) ->
+    undefined.
+
+determine_rotator_mod({ok, Mod}, _Default) when is_atom(Mod) ->
+    Mod;
+determine_rotator_mod(_, Default) ->
+    Default.
+
+decide_crash_log(undefined) ->
+    [];
+decide_crash_log(false) ->
+    [];
+decide_crash_log(File) ->
+    MaxBytes = validate_positive(application:get_env(lager, crash_log_msg_size), 65536),
+    RotationSize = validate_positive(application:get_env(lager, crash_log_size), 0),
+    RotationCount = validate_positive(application:get_env(lager, crash_log_count), 0),
+
+    RotationDate = determine_rotation_date(application:get_env(lager, crash_log_date)),
+    RotationMod = determine_rotator_mod(application:get_env(lager, crash_log_rotator), lager_rotator_default),
+
+
+    [{lager_crash_log, {lager_crash_log, start_link, [File, MaxBytes,
+                                                      RotationSize, RotationDate, RotationCount, RotationMod]},
+      permanent, 5000, worker, [lager_crash_log]}].

guam-0.9.11.tar.gz/_checkouts/lager/src/lager_transform.erl Added

@@ -0,0 +1,336 @@
+%% Copyright (c) 2011-2012 Basho Technologies, Inc. All Rights Reserved.
+%%
+%% This file is provided to you 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.
+
+%% @doc The parse transform used for lager messages.
+%% This parse transform rewrites functions calls to lager:Severity/1,2 into
+%% a more complicated function that captures module, function, line, pid and
+%% time as well. The entire function call is then wrapped in a case that
+%% checks the lager_config 'loglevel' value, so the code isn't executed if
+%% nothing wishes to consume the message.
+
+-module(lager_transform).
+
+-include("lager.hrl").
+
+-export([parse_transform/2]).
+
+%% @private
+parse_transform(AST, Options) ->
+ TruncSize = proplists:get_value(lager_truncation_size, Options, ?DEFAULT_TRUNCATION),
+ Enable = proplists:get_value(lager_print_records_flag, Options, true),
+ Sinks = [lager] ++ proplists:get_value(lager_extra_sinks, Options, []),
+ Functions = proplists:get_value(lager_function_transforms, Options, []),
+ put(print_records_flag, Enable),
+ put(truncation_size, TruncSize),
+ put(sinks, Sinks),
+ put(functions, lists:keysort(1, Functions)),
+ erlang:put(records, []),
+ %% .app file should either be in the outdir, or the same dir as the source file
+ guess_application(proplists:get_value(outdir, Options), hd(AST)),
+ walk_ast([], AST).
+
+walk_ast(Acc, []) ->
+ case get(print_records_flag) of
+ true ->
+ insert_record_attribute(Acc);
+ false ->
+ lists:reverse(Acc)
+ end;
+walk_ast(Acc, [{attribute, _, module, {Module, _PmodArgs}}=H|T]) ->
+ %% A wild parameterized module appears!
+ put(module, Module),
+ walk_ast([H|Acc], T);
+walk_ast(Acc, [{attribute, _, module, Module}=H|T]) ->
+ put(module, Module),
+ walk_ast([H|Acc], T);
+walk_ast(Acc, [{attribute, _, lager_function_transforms, FromModule }=H|T]) ->
+ %% Merge transform options from the module over the compile options
+ FromOptions = get(functions),
+ put(functions, orddict:merge(fun(_Key, _V1, V2) -> V2 end, FromOptions, lists:keysort(1, FromModule))),
+ walk_ast([H|Acc], T);
+walk_ast(Acc, [{function, Line, Name, Arity, Clauses}|T]) ->
+ put(function, Name),
+ walk_ast([{function, Line, Name, Arity,
+ walk_clauses([], Clauses)}|Acc], T);
+walk_ast(Acc, [{attribute, _, record, {Name, Fields}}=H|T]) ->
+ FieldNames = lists:map(fun record_field_name/1, Fields),
+ stash_record({Name, FieldNames}),
+ walk_ast([H|Acc], T);
+walk_ast(Acc, [H|T]) ->
+ walk_ast([H|Acc], T).
+
+record_field_name({record_field, _, {atom, _, FieldName}}) ->
+ FieldName;
+record_field_name({record_field, _, {atom, _, FieldName}, _Default}) ->
+ FieldName;
+record_field_name({typed_record_field, Field, _Type}) ->
+ record_field_name(Field).
+
+walk_clauses(Acc, []) ->
+ lists:reverse(Acc);
+walk_clauses(Acc, [{clause, Line, Arguments, Guards, Body}|T]) ->
+ walk_clauses([{clause, Line, Arguments, Guards, walk_body([], Body)}|Acc], T).
+
+walk_body(Acc, []) ->
+ lists:reverse(Acc);
+walk_body(Acc, [H|T]) ->
+ walk_body([transform_statement(H, get(sinks))|Acc], T).
+
+transform_statement({call, Line, {remote, _Line1, {atom, _Line2, Module},
+ {atom, _Line3, Function}}, Arguments0} = Stmt,
+ Sinks) ->
+ case lists:member(Module, Sinks) of
+ true ->
+ case lists:member(Function, ?LEVELS) of
+ true ->
+ SinkName = lager_util:make_internal_sink_name(Module),
+ do_transform(Line, SinkName, Function, Arguments0);
+ false ->
+ case lists:keyfind(Function, 1, ?LEVELS_UNSAFE) of
+ {Function, Severity} ->
+ SinkName = lager_util:make_internal_sink_name(Module),
+ do_transform(Line, SinkName, Severity, Arguments0, unsafe);
+ false ->
+ Stmt
+ end
+ end;
+ false ->
+ list_to_tuple(transform_statement(tuple_to_list(Stmt), Sinks))
+ end;
+transform_statement(Stmt, Sinks) when is_tuple(Stmt) ->
+ list_to_tuple(transform_statement(tuple_to_list(Stmt), Sinks));
+transform_statement(Stmt, Sinks) when is_list(Stmt) ->
+ [transform_statement(S, Sinks) || S <- Stmt];
+transform_statement(Stmt, _Sinks) ->
+ Stmt.
+
+
+add_function_transforms(_Line, DefaultAttrs, []) ->
+ DefaultAttrs;
+add_function_transforms(Line, DefaultAttrs, [{Atom, on_emit, {Module, Function}}|Remainder]) ->
+ NewFunction = {tuple, Line, [
+ {atom, Line, Atom},
+ {'fun', Line, {
+ function, {atom, Line, Module}, {atom, Line, Function}, {integer, Line, 0}
+ }}
+ ]},
+ add_function_transforms(Line, {cons, Line, NewFunction, DefaultAttrs}, Remainder);
+add_function_transforms(Line, DefaultAttrs, [{Atom, on_log, {Module, Function}}|Remainder]) ->
+ NewFunction = {tuple, Line, [
+ {atom, Line, Atom},
+ {call, Line, {remote, Line, {atom, Line, Module}, {atom, Line, Function}}, []}
+ ]},
+ add_function_transforms(Line, {cons, Line, NewFunction, DefaultAttrs}, Remainder).
+
+
+do_transform(Line, SinkName, Severity, Arguments0) ->
+ do_transform(Line, SinkName, Severity, Arguments0, safe).
+
+do_transform(Line, SinkName, Severity, Arguments0, Safety) ->
+ SeverityAsInt=lager_util:level_to_num(Severity),
+ DefaultAttrs0 = {cons, Line, {tuple, Line, [
+ {atom, Line, module}, {atom, Line, get(module)}]},
+ {cons, Line, {tuple, Line, [
+ {atom, Line, function}, {atom, Line, get(function)}]},
+ {cons, Line, {tuple, Line, [
+ {atom, Line, line},
+ {integer, Line, Line}]},
+ {cons, Line, {tuple, Line, [
+ {atom, Line, pid},
+ {call, Line, {atom, Line, pid_to_list}, [
+ {call, Line, {atom, Line ,self}, []}]}]},
+ {cons, Line, {tuple, Line, [
+ {atom, Line, node},
+ {call, Line, {atom, Line, node}, []}]},
+ %% get the metadata with lager:md(), this will always return a list so we can use it as the tail here
+ {call, Line, {remote, Line, {atom, Line, lager}, {atom, Line, md}}, []}}}}}},
+ %{nil, Line}}}}}}},
+ Functions = get(functions),
+ DefaultAttrs1 = add_function_transforms(Line, DefaultAttrs0, Functions),
+ DefaultAttrs = case erlang:get(application) of
+ undefined ->
+ DefaultAttrs1;
+ App ->
+ %% stick the application in the attribute list
+ concat_lists({cons, Line, {tuple, Line, [
+ {atom, Line, application},
+ {atom, Line, App}]},
+ {nil, Line}}, DefaultAttrs1)
+ end,
+ {Meta, Message, Arguments} = handle_args(DefaultAttrs, Line, Arguments0),
+ %% Generate some unique variable names so we don't accidentally export from case clauses.
+ %% Note that these are not actual atoms, but the AST treats variable names as atoms.
+ LevelVar = make_varname("__Level", Line),
+ TracesVar = make_varname("__Traces", Line),
+ PidVar = make_varname("__Pid", Line),
+ LogFun = case Safety of
+ safe ->
+ do_log;
+ unsafe ->
+ do_log_unsafe
+ end,
+ %% Wrap the call to lager:dispatch_log/6 in case that will avoid doing any work if this message is not elegible for logging
+ %% See lager.erl (lines 89-100) for lager:dispatch_log/6
+ %% case {whereis(Sink), whereis(?DEFAULT_SINK), lager_config:get({Sink, loglevel}, {?LOG_NONE, []})} of
+ {'case',Line,
+ {tuple,Line,
+ [{call,Line,{atom,Line,whereis},[{atom,Line,SinkName}]},
+ {call,Line,{atom,Line,whereis},[{atom,Line,?DEFAULT_SINK}]}, 
+ {call,Line,
+ {remote,Line,{atom,Line,lager_config},{atom,Line,get}},
+ [{tuple,Line,[{atom,Line,SinkName},{atom,Line,loglevel}]},
+ {tuple,Line,[{integer,Line,0},{nil,Line}]}]}]},
+ %% {undefined, undefined, _} -> {error, lager_not_running};
+ [{clause,Line,
+ [{tuple,Line,
+ [{atom,Line,undefined},{atom,Line,undefined},{var,Line,'_'}]}],
+ [],
+ [{tuple, erl_anno:set_generated(true, Line), [{atom, Line, error},{atom, Line, lager_not_running}]}]
+ },
+ %% {undefined, _, _} -> {error, {sink_not_configured, Sink}};
+ {clause,Line,
+ [{tuple,Line,
+ [{atom,Line,undefined},{var,Line,'_'},{var,Line,'_'}]}],
+ [],
+ [{tuple, erl_anno:set_generated(true, Line), [{atom,Line,error}, {tuple,Line,[{atom,Line,sink_not_configured},{atom,Line,SinkName}]}]}]
+ },
+ %% {SinkPid, _, {Level, Traces}} when ... -> lager:do_log/9;
+ {clause,Line,
+ [{tuple,Line,
+ [{var,Line,PidVar},
+ {var,Line,'_'},
+ {tuple,Line,[{var,Line,LevelVar},{var,Line,TracesVar}]}]}],
+ [[{op, Line, 'orelse',
+ {op, Line, '/=', {op, Line, 'band', {var, Line, LevelVar}, {integer, Line, SeverityAsInt}}, {integer, Line, 0}},
+ {op, Line, '/=', {var, Line, TracesVar}, {nil, Line}}}]],
+ [{call,Line,{remote, Line, {atom, Line, lager}, {atom, Line, LogFun}},
+ [{atom,Line,Severity},
+ Meta,
+ Message,
+ Arguments,
+ {integer, Line, get(truncation_size)},
+ {integer, Line, SeverityAsInt},
+ {var, Line, LevelVar},
+ {var, Line, TracesVar},
+ {atom, Line, SinkName},
+ {var, Line, PidVar}]}]},
+ %% _ -> ok
+ {clause,Line,[{var,Line,'_'}],[],[{atom,Line,ok}]}]}.
+ 
+handle_args(DefaultAttrs, Line, [{cons, LineNum, {tuple, _, _}, _} = Attrs]) ->
+ {concat_lists(DefaultAttrs, Attrs), {string, LineNum, ""}, {atom, Line, none}};
+handle_args(DefaultAttrs, Line, [Format]) ->
+ {DefaultAttrs, Format, {atom, Line, none}};
+handle_args(DefaultAttrs, Line, [Arg1, Arg2]) ->
+ %% some ambiguity here, figure out if these arguments are
+ %% [Format, Args] or [Attr, Format].
+ %% The trace attributes will be a list of tuples, so check
+ %% for that.
+ case {element(1, Arg1), Arg1} of
+ {_, {cons, _, {tuple, _, _}, _}} ->
+ {concat_lists(Arg1, DefaultAttrs),
+ Arg2, {atom, Line, none}};
+ {Type, _} when Type == var;
+ Type == lc;
+ Type == call;
+ Type == record_field ->
+ %% crap, its not a literal. look at the second
+ %% argument to see if it is a string
+ case Arg2 of
+ {string, _, _} ->
+ {concat_lists(Arg1, DefaultAttrs),
+ Arg2, {atom, Line, none}};
+ _ ->
+ %% not a string, going to have to guess
+ %% it's the argument list
+ {DefaultAttrs, Arg1, Arg2}
+ end;
+ _ ->
+ {DefaultAttrs, Arg1, Arg2}
+ end;
+handle_args(DefaultAttrs, _Line, [Attrs, Format, Args]) ->
+ {concat_lists(Attrs, DefaultAttrs), Format, Args}.
+
+make_varname(Prefix, CallAnno) ->
+ list_to_atom(Prefix ++ atom_to_list(get(module)) ++ integer_to_list(erl_anno:line(CallAnno))).
+
+%% concat 2 list ASTs by replacing the terminating [] in A with the contents of B
+concat_lists({var, Line, _Name}=Var, B) ->
+ %% concatenating a var with a cons
+ {call, Line, {remote, Line, {atom, Line, lists},{atom, Line, flatten}},
+ [{cons, Line, Var, B}]};
+concat_lists({lc, Line, _Body, _Generator} = LC, B) ->
+ %% concatenating a LC with a cons
+ {call, Line, {remote, Line, {atom, Line, lists},{atom, Line, flatten}},
+ [{cons, Line, LC, B}]};
+concat_lists({call, Line, _Function, _Args} = Call, B) ->
+ %% concatenating a call with a cons
+ {call, Line, {remote, Line, {atom, Line, lists},{atom, Line, flatten}},
+ [{cons, Line, Call, B}]};
+concat_lists({record_field, Line, _Var, _Record, _Field} = Rec, B) ->
+ %% concatenating a record_field with a cons
+ {call, Line, {remote, Line, {atom, Line, lists},{atom, Line, flatten}},
+ [{cons, Line, Rec, B}]};
+concat_lists({nil, _Line}, B) ->
+ B;
+concat_lists({cons, Line, Element, Tail}, B) ->
+ {cons, Line, Element, concat_lists(Tail, B)}.
+
+stash_record(Record) ->
+ Records = case erlang:get(records) of
+ undefined ->
+ [];
+ R ->
+ R
+ end,
+ erlang:put(records, [Record|Records]).
+
+insert_record_attribute(AST) ->
+ lists:foldl(fun({attribute, Line, module, _}=E, Acc) ->
+ [E, {attribute, Line, lager_records, erlang:get(records)}|Acc];
+ (E, Acc) ->
+ [E|Acc]
+ end, [], AST).
+
+guess_application(Dirname, Attr) when Dirname /= undefined ->
+ case find_app_file(Dirname) of
+ no_idea ->
+ %% try it based on source file directory (app.src most likely)
+ guess_application(undefined, Attr);
+ _ ->
+ ok
+ end;
+guess_application(undefined, {attribute, _, file, {Filename, _}}) ->
+ Dir = filename:dirname(Filename),
+ find_app_file(Dir);
+guess_application(_, _) ->
+ ok.
+
+find_app_file(Dir) ->
+ case filelib:wildcard(Dir++"/*.{app,app.src}") of
+ [] ->
+ no_idea;
+ [File] ->
+ case file:consult(File) of
+ {ok, [{application, Appname, _Attributes}|_]} ->
+ erlang:put(application, Appname);
+ _ ->
+ no_idea
+ end;
+ _ ->
+ %% multiple files, uh oh
+ no_idea
+ end.

guam-0.9.11.tar.gz/_checkouts/lager/src/lager_trunc_io.erl Added

@@ -0,0 +1,878 @@
+%% ``The contents of this file are subject to the Erlang Public License,
+%% Version 1.1, (the "License"); you may not use this file except in
+%% compliance with the License. You should have received a copy of the
+%% Erlang Public License along with your Erlang distribution. If not, it can be
+%% retrieved via the world wide web at http://www.erlang.org/.
+%%
+%% Software distributed under the License is distributed on an "AS IS"
+%% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
+%% the License for the specific language governing rights and limitations
+%% under the License.
+%%
+%% The Initial Developer of the Original Code is Corelatus AB.
+%% Portions created by Corelatus are Copyright 2003, Corelatus
+%% AB. All Rights Reserved.''
+%%
+%% @doc Module to print out terms for logging. Limits by length rather than depth.
+%%
+%% The resulting string may be slightly larger than the limit; the intention
+%% is to provide predictable CPU and memory consumption for formatting
+%% terms, not produce precise string lengths.
+%%
+%% Typical use:
+%%
+%% trunc_io:print(Term, 500).
+%%
+%% Source license: Erlang Public License.
+%% Original author: Matthias Lang, <tt>matthias@corelatus.se</tt>
+%%
+%% Various changes to this module, most notably the format/3 implementation
+%% were added by Andrew Thompson `<andrew@basho.com>'. The module has been renamed
+%% to avoid conflicts with the vanilla module.
+
+-module(lager_trunc_io).
+-author('matthias@corelatus.se').
+%% And thanks to Chris Newcombe for a bug fix
+-export([format/3, format/4, print/2, print/3, fprint/2, fprint/3, safe/2]). % interface functions
+-version("$Id: trunc_io.erl,v 1.11 2009-02-23 12:01:06 matthias Exp $").
+
+-ifdef(TEST).
+-export([perf/0, perf/3, perf1/0, test/0, test/2]). % testing functions
+-include_lib("eunit/include/eunit.hrl").
+-endif.
+
+-type option() :: {'depth', integer()}
+ | {'lists_as_strings', boolean()}
+ | {'force_strings', boolean()}.
+-type options() :: [option()].
+
+-record(print_options, {
+ %% negative depth means no depth limiting
+ depth = -1 :: integer(),
+ %% whether to print lists as strings, if possible
+ lists_as_strings = true :: boolean(),
+ %% force strings, or binaries to be printed as a string,
+ %% even if they're not printable
+ force_strings = false :: boolean()
+ }).
+
+format(Fmt, Args, Max) ->
+ format(Fmt, Args, Max, []).
+
+format(Fmt, Args, Max, Options) ->
+ try lager_format:format(Fmt, Args, Max, Options)
+ catch
+ _What:_Why ->
+ erlang:error(badarg, [Fmt, Args])
+ end.
+
+%% @doc Returns an flattened list containing the ASCII representation of the given
+%% term.
+-spec fprint(term(), pos_integer()) -> string().
+fprint(Term, Max) ->
+ fprint(Term, Max, []).
+
+
+%% @doc Returns an flattened list containing the ASCII representation of the given
+%% term.
+-spec fprint(term(), pos_integer(), options()) -> string().
+fprint(T, Max, Options) ->
+ {L, _} = print(T, Max, prepare_options(Options, #print_options{})),
+ lists:flatten(L).
+
+%% @doc Same as print, but never crashes.
+%%
+%% This is a tradeoff. Print might conceivably crash if it's asked to
+%% print something it doesn't understand, for example some new data
+%% type in a future version of Erlang. If print crashes, we fall back
+%% to io_lib to format the term, but then the formatting is
+%% depth-limited instead of length limited, so you might run out
+%% memory printing it. Out of the frying pan and into the fire.
+%%
+-spec safe(term(), pos_integer()) -> {string(), pos_integer()} | {string()}.
+safe(What, Len) ->
+ case catch print(What, Len) of
+ {L, Used} when is_list(L) -> {L, Used};
+ _ -> {"unable to print" ++ io_lib:write(What, 99)}
+ end.
+
+%% @doc Returns {List, Length}
+-spec print(term(), pos_integer()) -> {iolist(), pos_integer()}.
+print(Term, Max) ->
+ print(Term, Max, []).
+
+%% @doc Returns {List, Length}
+-spec print(term(), pos_integer(), options() | #print_options{}) -> {iolist(), pos_integer()}.
+print(Term, Max, Options) when is_list(Options) ->
+ %% need to convert the proplist to a record
+ print(Term, Max, prepare_options(Options, #print_options{}));
+
+print(Term, _Max, #print_options{force_strings=true}) when not is_list(Term), not is_binary(Term), not is_atom(Term) ->
+ erlang:error(badarg);
+
+print(_, Max, _Options) when Max < 0 -> {"...", 3};
+print(_, _, #print_options{depth=0}) -> {"...", 3};
+
+
+%% @doc We assume atoms, floats, funs, integers, PIDs, ports and refs never need
+%% to be truncated. This isn't strictly true, someone could make an
+%% arbitrarily long bignum. Let's assume that won't happen unless someone
+%% is being malicious.
+%%
+print(Atom, _Max, #print_options{force_strings=NoQuote}) when is_atom(Atom) ->
+ L = atom_to_list(Atom),
+ R = case atom_needs_quoting_start(L) andalso not NoQuote of
+ true -> lists:flatten([$', L, $']);
+ false -> L
+ end,
+ {R, length(R)};
+
+print(<<>>, _Max, #print_options{depth=1}) ->
+ {"<<>>", 4};
+print(Bin, _Max, #print_options{depth=1}) when is_binary(Bin) ->
+ {"<<...>>", 7};
+print(<<>>, _Max, Options) ->
+ case Options#print_options.force_strings of
+ true ->
+ {"", 0};
+ false ->
+ {"<<>>", 4}
+ end;
+
+print(Binary, 0, _Options) when is_bitstring(Binary) ->
+ {"<<..>>", 6};
+
+print(Bin, Max, _Options) when is_binary(Bin), Max < 2 ->
+ {"<<...>>", 7};
+print(Binary, Max, Options) when is_binary(Binary) ->
+ B = binary_to_list(Binary, 1, lists:min([Max, byte_size(Binary)])),
+ {Res, Length} = case Options#print_options.lists_as_strings orelse
+ Options#print_options.force_strings of
+ true ->
+ Depth = Options#print_options.depth,
+ MaxSize = (Depth - 1) * 4,
+ %% check if we need to truncate based on depth
+ In = case Depth > -1 andalso MaxSize < length(B) andalso
+ not Options#print_options.force_strings of
+ true ->
+ string:substr(B, 1, MaxSize);
+ false -> B
+ end,
+ MaxLen = case Options#print_options.force_strings of
+ true ->
+ Max;
+ false ->
+ %% make room for the leading doublequote
+ Max - 1
+ end,
+ try alist(In, MaxLen, Options) of
+ {L0, Len0} ->
+ case Options#print_options.force_strings of
+ false ->
+ case B /= In of
+ true ->
+ {[$", L0, "..."], Len0+4};
+ false ->
+ {[$"|L0], Len0+1}
+ end;
+ true ->
+ {L0, Len0}
+ end
+ catch
+ throw:{unprintable, C} ->
+ Index = string:chr(In, C),
+ case Index > 1 andalso Options#print_options.depth =< Index andalso
+ Options#print_options.depth > -1 andalso
+ not Options#print_options.force_strings of
+ true ->
+ %% print first Index-1 characters followed by ...
+ {L0, Len0} = alist_start(string:substr(In, 1, Index - 1), Max - 1, Options),
+ {L0++"...", Len0+3};
+ false ->
+ list_body(In, Max-4, dec_depth(Options), true)
+ end
+ end;
+ _ ->
+ list_body(B, Max-4, dec_depth(Options), true)
+ end,
+ case Options#print_options.force_strings of
+ true ->
+ {Res, Length};
+ _ ->
+ {["<<", Res, ">>"], Length+4}
+ end;
+
+%% bitstrings are binary's evil brother who doesn't end on an 8 bit boundary.
+%% This makes printing them extremely annoying, so list_body/list_bodyc has
+%% some magic for dealing with the output of bitstring_to_list, which returns
+%% a list of integers (as expected) but with a trailing binary that represents
+%% the remaining bits.
+print({inline_bitstring, B}, _Max, _Options) when is_bitstring(B) ->
+ Size = bit_size(B),
+ <<Value:Size>> = B,
+ ValueStr = integer_to_list(Value),
+ SizeStr = integer_to_list(Size),
+ {[ValueStr, $:, SizeStr], length(ValueStr) + length(SizeStr) +1};
+print(BitString, Max, Options) when is_bitstring(BitString) ->
+ BL = case byte_size(BitString) > Max of
+ true ->
+ binary_to_list(BitString, 1, Max);
+ _ ->
+ R = erlang:bitstring_to_list(BitString),
+ {Bytes, [Bits]} = lists:splitwith(fun erlang:is_integer/1, R),
+ %% tag the trailing bits with a special tuple we catch when
+ %% list_body calls print again
+ Bytes ++ [{inline_bitstring, Bits}]
+ end,
+ {X, Len0} = list_body(BL, Max - 4, dec_depth(Options), true),
+ {["<<", X, ">>"], Len0 + 4};
+
+print(Float, _Max, _Options) when is_float(Float) ->
+ %% use the same function io_lib:format uses to print floats
+ %% float_to_list is way too verbose.
+ L = io_lib_format:fwrite_g(Float),
+ {L, length(L)};
+
+print(Fun, Max, _Options) when is_function(Fun) ->
+ L = erlang:fun_to_list(Fun),
+ case length(L) > Max of
+ true ->
+ S = erlang:max(5, Max),
+ Res = string:substr(L, 1, S) ++ "..>",
+ {Res, length(Res)};
+ _ ->
+ {L, length(L)}
+ end;
+
+print(Integer, _Max, _Options) when is_integer(Integer) ->
+ L = integer_to_list(Integer),
+ {L, length(L)};
+
+print(Pid, _Max, _Options) when is_pid(Pid) ->
+ L = pid_to_list(Pid),
+ {L, length(L)};
+
+print(Ref, _Max, _Options) when is_reference(Ref) ->
+ L = erlang:ref_to_list(Ref),
+ {L, length(L)};
+
+print(Port, _Max, _Options) when is_port(Port) ->
+ L = erlang:port_to_list(Port),
+ {L, length(L)};
+
+print({'$lager_record', Name, Fields}, Max, Options) ->
+ Leader = "#" ++ atom_to_list(Name) ++ "{",
+ {RC, Len} = record_fields(Fields, Max - length(Leader) + 1, dec_depth(Options)),
+ {[Leader, RC, "}"], Len + length(Leader) + 1};
+
+print(Tuple, Max, Options) when is_tuple(Tuple) ->
+ {TC, Len} = tuple_contents(Tuple, Max-2, Options),
+ {[${, TC, $}], Len + 2};
+
+print(List, Max, Options) when is_list(List) ->
+ case Options#print_options.lists_as_strings orelse
+ Options#print_options.force_strings of
+ true ->
+ alist_start(List, Max, dec_depth(Options));
+ _ ->
+ {R, Len} = list_body(List, Max - 2, dec_depth(Options), false),
+ {[$[, R, $]], Len + 2}
+ end;
+
+print(Map, Max, Options) when is_map(Map) ->
+ {MapBody, Len} = map_body(Map, Max - 3, dec_depth(Options)),
+ {[$#, ${, MapBody, $}], Len + 3};
+
+print(Term, Max, Options) ->
+ error(badarg, [Term, Max, Options]).
+
+%% Returns {List, Length}
+tuple_contents(Tuple, Max, Options) ->
+ L = tuple_to_list(Tuple),
+ list_body(L, Max, dec_depth(Options), true).
+
+%% Format the inside of a list, i.e. do not add a leading [ or trailing ].
+%% Returns {List, Length}
+list_body([], _Max, _Options, _Tuple) -> {[], 0};
+list_body(_, Max, _Options, _Tuple) when Max < 4 -> {"...", 3};
+list_body(_, _Max, #print_options{depth=0}, _Tuple) -> {"...", 3};
+list_body([H], Max, Options=#print_options{depth=1}, _Tuple) ->
+ print(H, Max, Options);
+list_body([H|_], Max, Options=#print_options{depth=1}, Tuple) ->
+ {List, Len} = print(H, Max-4, Options),
+ Sep = case Tuple of
+ true -> $,;
+ false -> $|
+ end,
+ {[List ++ [Sep | "..."]], Len + 4};
+list_body([H|T], Max, Options, Tuple) ->
+ {List, Len} = print(H, Max, Options),
+ {Final, FLen} = list_bodyc(T, Max - Len, Options, Tuple),
+ {[List|Final], FLen + Len};
+list_body(X, Max, Options, _Tuple) -> %% improper list
+ {List, Len} = print(X, Max - 1, Options),
+ {[$|,List], Len + 1}.
+
+list_bodyc([], _Max, _Options, _Tuple) -> {[], 0};
+list_bodyc(_, Max, _Options, _Tuple) when Max < 5 -> {",...", 4};
+list_bodyc(_, _Max, #print_options{depth=1}, true) -> {",...", 4};
+list_bodyc(_, _Max, #print_options{depth=1}, false) -> {"|...", 4};
+list_bodyc([H|T], Max, #print_options{depth=Depth} = Options, Tuple) ->
+ {List, Len} = print(H, Max, dec_depth(Options)),
+ {Final, FLen} = list_bodyc(T, Max - Len - 1, dec_depth(Options), Tuple),
+ Sep = case Depth == 1 andalso not Tuple of
+ true -> $|;
+ _ -> $,
+ end,
+ {[Sep, List|Final], FLen + Len + 1};
+list_bodyc(X, Max, Options, _Tuple) -> %% improper list
+ {List, Len} = print(X, Max - 1, Options),
+ {[$|,List], Len + 1}.
+
+map_body(Map, Max, #print_options{depth=Depth}) when Max < 4; Depth =:= 0 ->
+ case erlang:map_size(Map) of
+ 0 -> {[], 0};
+ _ -> {"...", 3}
+ end;
+map_body(Map, Max, Options) ->
+ case maps:to_list(Map) of
+ [] ->
+ {[], 0};
+ [{Key, Value} | Rest] ->
+ {KeyStr, KeyLen} = print(Key, Max - 4, Options),
+ DiffLen = KeyLen + 4,
+ {ValueStr, ValueLen} = print(Value, Max - DiffLen, Options),
+ DiffLen2 = DiffLen + ValueLen,
+ {Final, FLen} = map_bodyc(Rest, Max - DiffLen2, dec_depth(Options)),
+ {[KeyStr, " => ", ValueStr | Final], DiffLen2 + FLen}
+ end.
+
+map_bodyc([], _Max, _Options) ->
+ {[], 0};
+map_bodyc(_Rest, Max,#print_options{depth=Depth}) when Max < 5; Depth =:= 0 ->
+ {",...", 4};
+map_bodyc([{Key, Value} | Rest], Max, Options) ->
+ {KeyStr, KeyLen} = print(Key, Max - 5, Options),
+ DiffLen = KeyLen + 5,
+ {ValueStr, ValueLen} = print(Value, Max - DiffLen, Options),
+ DiffLen2 = DiffLen + ValueLen,
+ {Final, FLen} = map_bodyc(Rest, Max - DiffLen2, dec_depth(Options)),
+ {[$,, KeyStr, " => ", ValueStr | Final], DiffLen2 + FLen}.
+
+%% The head of a list we hope is ascii. Examples:
+%%
+%% [65,66,67] -> "ABC"
+%% [65,0,67] -> "A"[0,67]
+%% [0,65,66] -> [0,65,66]
+%% [65,b,66] -> "A"[b,66]
+%%
+alist_start([], _Max, #print_options{force_strings=true}) -> {"", 0};
+alist_start([], _Max, _Options) -> {"[]", 2};
+alist_start(_, Max, _Options) when Max < 4 -> {"...", 3};
+alist_start(_, _Max, #print_options{depth=0}) -> {"[...]", 5};
+alist_start(L, Max, #print_options{force_strings=true} = Options) ->
+ alist(L, Max, Options);
+%alist_start([H|_T], _Max, #print_options{depth=1}) when is_integer(H) -> {[$[, H, $|, $., $., $., $]], 7};
+alist_start([H|T], Max, Options) when is_integer(H), H >= 16#20, H =< 16#7e -> % definitely printable
+ try alist([H|T], Max -1, Options) of
+ {L, Len} ->
+ {[$"|L], Len + 1}
+ catch
+ throw:{unprintable, _} ->
+ {R, Len} = list_body([H|T], Max-2, Options, false),
+ {[$[, R, $]], Len + 2}
+ end;
+alist_start([H|T], Max, Options) when is_integer(H), H >= 16#a0, H =< 16#ff -> % definitely printable
+ try alist([H|T], Max -1, Options) of
+ {L, Len} ->
+ {[$"|L], Len + 1}
+ catch
+ throw:{unprintable, _} ->
+ {R, Len} = list_body([H|T], Max-2, Options, false),
+ {[$[, R, $]], Len + 2}
+ end;
+alist_start([H|T], Max, Options) when H =:= $\t; H =:= $\n; H =:= $\r; H =:= $\v; H =:= $\e; H=:= $\f; H=:= $\b ->
+ try alist([H|T], Max -1, Options) of
+ {L, Len} ->
+ {[$"|L], Len + 1}
+ catch
+ throw:{unprintable, _} ->
+ {R, Len} = list_body([H|T], Max-2, Options, false),
+ {[$[, R, $]], Len + 2}
+ end;
+alist_start(L, Max, Options) ->
+ {R, Len} = list_body(L, Max-2, Options, false),
+ {[$[, R, $]], Len + 2}.
+
+alist([], _Max, #print_options{force_strings=true}) -> {"", 0};
+alist([], _Max, _Options) -> {"\"", 1};
+alist(_, Max, #print_options{force_strings=true}) when Max < 4 -> {"...", 3};
+alist(_, Max, #print_options{force_strings=false}) when Max < 5 -> {"...\"", 4};
+alist([H|T], Max, Options = #print_options{force_strings=false,lists_as_strings=true}) when H =:= $"; H =:= $\\ ->
+ %% preserve escaping around quotes
+ {L, Len} = alist(T, Max-1, Options),
+ {[$\\,H|L], Len + 2};
+alist([H|T], Max, Options) when is_integer(H), H >= 16#20, H =< 16#7e -> % definitely printable
+ {L, Len} = alist(T, Max-1, Options),
+ {[H|L], Len + 1};
+alist([H|T], Max, Options) when is_integer(H), H >= 16#a0, H =< 16#ff -> % definitely printable
+ {L, Len} = alist(T, Max-1, Options),
+ {[H|L], Len + 1};
+alist([H|T], Max, Options) when H =:= $\t; H =:= $\n; H =:= $\r; H =:= $\v; H =:= $\e; H=:= $\f; H=:= $\b ->
+ {L, Len} = alist(T, Max-1, Options),
+ case Options#print_options.force_strings of
+ true ->
+ {[H|L], Len + 1};
+ _ ->
+ {[escape(H)|L], Len + 1}
+ end;
+alist([H|T], Max, #print_options{force_strings=true} = Options) when is_integer(H) ->
+ {L, Len} = alist(T, Max-1, Options),
+ {[H|L], Len + 1};
+alist([H|T], Max, Options = #print_options{force_strings=true}) when is_binary(H); is_list(H) ->
+ {List, Len} = print(H, Max, Options),
+ case (Max - Len) =< 0 of
+ true ->
+ %% no more room to print anything
+ {List, Len};
+ false ->
+ %% no need to decrement depth, as we're in printable string mode
+ {Final, FLen} = alist(T, Max - Len, Options),
+ {[List|Final], FLen+Len}
+ end;
+alist(_, _, #print_options{force_strings=true}) ->
+ erlang:error(badarg);
+alist([H|_L], _Max, _Options) ->
+ throw({unprintable, H});
+alist(H, _Max, _Options) ->
+ %% improper list
+ throw({unprintable, H}).
+
+%% is the first character in the atom alphabetic & lowercase?
+atom_needs_quoting_start([H|T]) when H >= $a, H =< $z ->
+ atom_needs_quoting(T);
+atom_needs_quoting_start(_) ->
+ true.
+
+atom_needs_quoting([]) ->
+ false;
+atom_needs_quoting([H|T]) when (H >= $a andalso H =< $z);
+ (H >= $A andalso H =< $Z);
+ (H >= $0 andalso H =< $9);
+ H == $@; H == $_ ->
+ atom_needs_quoting(T);
+atom_needs_quoting(_) ->
+ true.
+
+-spec prepare_options(options(), #print_options{}) -> #print_options{}.
+prepare_options([], Options) ->
+ Options;
+prepare_options([{depth, Depth}|T], Options) when is_integer(Depth) ->
+ prepare_options(T, Options#print_options{depth=Depth});
+prepare_options([{lists_as_strings, Bool}|T], Options) when is_boolean(Bool) ->
+ prepare_options(T, Options#print_options{lists_as_strings = Bool});
+prepare_options([{force_strings, Bool}|T], Options) when is_boolean(Bool) ->
+ prepare_options(T, Options#print_options{force_strings = Bool}).
+
+dec_depth(#print_options{depth=Depth} = Options) when Depth > 0 ->
+ Options#print_options{depth=Depth-1};
+dec_depth(Options) ->
+ Options.
+
+escape($\t) -> "\\t";
+escape($\n) -> "\\n";
+escape($\r) -> "\\r";
+escape($\e) -> "\\e";
+escape($\f) -> "\\f";
+escape($\b) -> "\\b";
+escape($\v) -> "\\v".
+
+record_fields([], _, _) ->
+ {"", 0};
+record_fields(_, Max, #print_options{depth=D}) when Max < 4; D == 0 ->
+ {"...", 3};
+record_fields([{Field, Value}|T], Max, Options) ->
+ {ExtraChars, Terminator} = case T of
+ [] ->
+ {1, []};
+ _ ->
+ {2, ","}
+ end,
+ {FieldStr, FieldLen} = print(Field, Max - ExtraChars, Options),
+ {ValueStr, ValueLen} = print(Value, Max - (FieldLen + ExtraChars), Options),
+ {Final, FLen} = record_fields(T, Max - (FieldLen + ValueLen + ExtraChars), dec_depth(Options)),
+ {[FieldStr++"="++ValueStr++Terminator|Final], FLen + FieldLen + ValueLen + ExtraChars}.
+
+
+-ifdef(TEST).
+%%--------------------
+%% The start of a test suite. So far, it only checks for not crashing.
+-spec test() -> ok.
+test() ->
+ test(trunc_io, print).
+
+-spec test(atom(), atom()) -> ok.
+test(Mod, Func) ->
+ Simple_items = [atom, 1234, 1234.0, {tuple}, [], [list], "string", self(),
+ <<1,2,3>>, make_ref(), fun() -> ok end],
+ F = fun(A) ->
+ Mod:Func(A, 100),
+ Mod:Func(A, 2),
+ Mod:Func(A, 20)
+ end,
+
+ G = fun(A) ->
+ case catch F(A) of
+ {'EXIT', _} -> exit({failed, A});
+ _ -> ok
+ end
+ end,
+
+ lists:foreach(G, Simple_items),
+
+ Tuples = [ {1,2,3,a,b,c}, {"abc", def, 1234},
+ {{{{a},b,c,{d},e}},f}],
+
+ Lists = [ [1,2,3,4,5,6,7], lists:seq(1,1000),
+ [{a}, {a,b}, {a, [b,c]}, "def"], [a|b], [$a|$b] ],
+
+
+ lists:foreach(G, Tuples),
+ lists:foreach(G, Lists).
+
+-spec perf() -> ok.
+perf() ->
+ {New, _} = timer:tc(trunc_io, perf, [trunc_io, print, 1000]),
+ {Old, _} = timer:tc(trunc_io, perf, [io_lib, write, 1000]),
+ io:fwrite("New code took ~p us, old code ~p\n", [New, Old]).
+
+-spec perf(atom(), atom(), integer()) -> done.
+perf(M, F, Reps) when Reps > 0 ->
+ test(M,F),
+ perf(M,F,Reps-1);
+perf(_,_,_) ->
+ done.
+
+%% Performance test. Needs a particularly large term I saved as a binary...
+-spec perf1() -> {non_neg_integer(), non_neg_integer()}.
+perf1() ->
+ {ok, Bin} = file:read_file("bin"),
+ A = binary_to_term(Bin),
+ {N, _} = timer:tc(trunc_io, print, [A, 1500]),
+ {M, _} = timer:tc(io_lib, write, [A]),
+ {N, M}.
+
+format_test() ->
+ %% simple format strings
+ ?assertEqual("foobar", lists:flatten(format("~s", [["foo", $b, $a, $r]], 50))),
+ ?assertEqual("[\"foo\",98,97,114]", lists:flatten(format("~p", [["foo", $b, $a, $r]], 50))),
+ ?assertEqual("[\"foo\",98,97,114]", lists:flatten(format("~P", [["foo", $b, $a, $r], 10], 50))),
+ ?assertEqual("[[102,111,111],98,97,114]", lists:flatten(format("~w", [["foo", $b, $a, $r]], 50))),
+
+ %% complex ones
+ ?assertEqual(" foobar", lists:flatten(format("~10s", [["foo", $b, $a, $r]], 50))),
+ ?assertEqual("f", lists:flatten(format("~1s", [["foo", $b, $a, $r]], 50))),
+ ?assertEqual("[\"foo\",98,97,114]", lists:flatten(format("~22p", [["foo", $b, $a, $r]], 50))),
+ ?assertEqual("[\"foo\",98,97,114]", lists:flatten(format("~22P", [["foo", $b, $a, $r], 10], 50))),
+ ?assertEqual("**********", lists:flatten(format("~10W", [["foo", $b, $a, $r], 10], 50))),
+ ?assertEqual("[[102,111,111],98,97,114]", lists:flatten(format("~25W", [["foo", $b, $a, $r], 10], 50))),
+ % Note these next two diverge from io_lib:format; the field width is
+ % ignored, when it should be used as max line length.
+ ?assertEqual("[\"foo\",98,97,114]", lists:flatten(format("~10p", [["foo", $b, $a, $r]], 50))),
+ ?assertEqual("[\"foo\",98,97,114]", lists:flatten(format("~10P", [["foo", $b, $a, $r], 10], 50))),
+ ok.
+
+atom_quoting_test() ->
+ ?assertEqual("hello", lists:flatten(format("~p", [hello], 50))),
+ ?assertEqual("'hello world'", lists:flatten(format("~p", ['hello world'], 50))),
+ ?assertEqual("'Hello world'", lists:flatten(format("~p", ['Hello world'], 50))),
+ ?assertEqual("hello_world", lists:flatten(format("~p", ['hello_world'], 50))),
+ ?assertEqual("'node@127.0.0.1'", lists:flatten(format("~p", ['node@127.0.0.1'], 50))),
+ ?assertEqual("node@nohost", lists:flatten(format("~p", [node@nohost], 50))),
+ ?assertEqual("abc123", lists:flatten(format("~p", [abc123], 50))),
+ ok.
+
+sane_float_printing_test() ->
+ ?assertEqual("1.0", lists:flatten(format("~p", [1.0], 50))),
+ ?assertEqual("1.23456789", lists:flatten(format("~p", [1.23456789], 50))),
+ ?assertEqual("1.23456789", lists:flatten(format("~p", [1.234567890], 50))),
+ ?assertEqual("0.3333333333333333", lists:flatten(format("~p", [1/3], 50))),
+ ?assertEqual("0.1234567", lists:flatten(format("~p", [0.1234567], 50))),
+ ok.
+
+float_inside_list_test() ->
+ ?assertEqual("[97,38.233913133184835,99]", lists:flatten(format("~p", [[$a, 38.233913133184835, $c]], 50))),
+ ?assertError(badarg, lists:flatten(format("~s", [[$a, 38.233913133184835, $c]], 50))),
+ ok.
+
+quote_strip_test() ->
+ ?assertEqual("\"hello\"", lists:flatten(format("~p", ["hello"], 50))),
+ ?assertEqual("hello", lists:flatten(format("~s", ["hello"], 50))),
+ ?assertEqual("hello", lists:flatten(format("~s", [hello], 50))),
+ ?assertEqual("hello", lists:flatten(format("~p", [hello], 50))),
+ ?assertEqual("'hello world'", lists:flatten(format("~p", ['hello world'], 50))),
+ ?assertEqual("hello world", lists:flatten(format("~s", ['hello world'], 50))),
+ ok.
+
+binary_printing_test() ->
+ ?assertEqual("<<>>", lists:flatten(format("~p", [<<>>], 50))),
+ ?assertEqual("", lists:flatten(format("~s", [<<>>], 50))),
+ ?assertEqual("<<..>>", lists:flatten(format("~p", [<<"hi">>], 0))),
+ ?assertEqual("<<...>>", lists:flatten(format("~p", [<<"hi">>], 1))),
+ ?assertEqual("<<\"hello\">>", lists:flatten(format("~p", [<<$h, $e, $l, $l, $o>>], 50))),
+ ?assertEqual("<<\"hello\">>", lists:flatten(format("~p", [<<"hello">>], 50))),
+ ?assertEqual("<<104,101,108,108,111>>", lists:flatten(format("~w", [<<"hello">>], 50))),
+ ?assertEqual("<<1,2,3,4>>", lists:flatten(format("~p", [<<1, 2, 3, 4>>], 50))),
+ ?assertEqual([1,2,3,4], lists:flatten(format("~s", [<<1, 2, 3, 4>>], 50))),
+ ?assertEqual("hello", lists:flatten(format("~s", [<<"hello">>], 50))),
+ ?assertEqual("hello\nworld", lists:flatten(format("~s", [<<"hello\nworld">>], 50))),
+ ?assertEqual("<<\"hello\\nworld\">>", lists:flatten(format("~p", [<<"hello\nworld">>], 50))),
+ ?assertEqual("<<\"\\\"hello world\\\"\">>", lists:flatten(format("~p", [<<"\"hello world\"">>], 50))),
+ ?assertEqual("<<\"hello\\\\world\">>", lists:flatten(format("~p", [<<"hello\\world">>], 50))),
+ ?assertEqual("<<\"hello\\\\\world\">>", lists:flatten(format("~p", [<<"hello\\\world">>], 50))),
+ ?assertEqual("<<\"hello\\\\\\\\world\">>", lists:flatten(format("~p", [<<"hello\\\\world">>], 50))),
+ ?assertEqual("<<\"hello\\bworld\">>", lists:flatten(format("~p", [<<"hello\bworld">>], 50))),
+ ?assertEqual("<<\"hello\\tworld\">>", lists:flatten(format("~p", [<<"hello\tworld">>], 50))),
+ ?assertEqual("<<\"hello\\nworld\">>", lists:flatten(format("~p", [<<"hello\nworld">>], 50))),
+ ?assertEqual("<<\"hello\\rworld\">>", lists:flatten(format("~p", [<<"hello\rworld">>], 50))),
+ ?assertEqual("<<\"hello\\eworld\">>", lists:flatten(format("~p", [<<"hello\eworld">>], 50))),
+ ?assertEqual("<<\"hello\\fworld\">>", lists:flatten(format("~p", [<<"hello\fworld">>], 50))),
+ ?assertEqual("<<\"hello\\vworld\">>", lists:flatten(format("~p", [<<"hello\vworld">>], 50))),
+ ?assertEqual(" hello", lists:flatten(format("~10s", [<<"hello">>], 50))),
+ ?assertEqual("[a]", lists:flatten(format("~s", [<<"[a]">>], 50))),
+ ?assertEqual("[a]", lists:flatten(format("~s", [[<<"[a]">>]], 50))),
+
+ ok.
+
+bitstring_printing_test() ->
+ ?assertEqual("<<1,2,3,1:7>>", lists:flatten(format("~p",
+ [<<1, 2, 3, 1:7>>], 100))),
+ ?assertEqual("<<1:7>>", lists:flatten(format("~p",
+ [<<1:7>>], 100))),
+ ?assertEqual("<<1,2,3,...>>", lists:flatten(format("~p",
+ [<<1, 2, 3, 1:7>>], 12))),
+ ?assertEqual("<<1,2,3,...>>", lists:flatten(format("~p",
+ [<<1, 2, 3, 1:7>>], 13))),
+ ?assertEqual("<<1,2,3,1:7>>", lists:flatten(format("~p",
+ [<<1, 2, 3, 1:7>>], 14))),
+ ?assertEqual("<<..>>", lists:flatten(format("~p", [<<1:7>>], 0))),
+ ?assertEqual("<<...>>", lists:flatten(format("~p", [<<1:7>>], 1))),
+ ?assertEqual("[<<1>>,<<2>>]", lists:flatten(format("~p", [[<<1>>, <<2>>]],
+ 100))),
+ ?assertEqual("{<<1:7>>}", lists:flatten(format("~p", [{<<1:7>>}], 50))),
+ ok.
+
+list_printing_test() ->
+ ?assertEqual("[]", lists:flatten(format("~p", [[]], 50))),
+ ?assertEqual("[]", lists:flatten(format("~w", [[]], 50))),
+ ?assertEqual("", lists:flatten(format("~s", [[]], 50))),
+ ?assertEqual("...", lists:flatten(format("~s", [[]], -1))),
+ ?assertEqual("[[]]", lists:flatten(format("~p", [[[]]], 50))),
+ ?assertEqual("[13,11,10,8,5,4]", lists:flatten(format("~p", [[13,11,10,8,5,4]], 50))),
+ ?assertEqual("\"\\rabc\"", lists:flatten(format("~p", [[13,$a, $b, $c]], 50))),
+ ?assertEqual("[1,2,3|4]", lists:flatten(format("~p", [[1, 2, 3|4]], 50))),
+ ?assertEqual("[...]", lists:flatten(format("~p", [[1, 2, 3,4]], 4))),
+ ?assertEqual("[1,...]", lists:flatten(format("~p", [[1, 2, 3, 4]], 6))),
+ ?assertEqual("[1,...]", lists:flatten(format("~p", [[1, 2, 3, 4]], 7))),
+ ?assertEqual("[1,2,...]", lists:flatten(format("~p", [[1, 2, 3, 4]], 8))),
+ ?assertEqual("[1|4]", lists:flatten(format("~p", [[1|4]], 50))),
+ ?assertEqual("[1]", lists:flatten(format("~p", [[1]], 50))),
+ ?assertError(badarg, lists:flatten(format("~s", [[1|4]], 50))),
+ ?assertEqual("\"hello...\"", lists:flatten(format("~p", ["hello world"], 10))),
+ ?assertEqual("hello w...", lists:flatten(format("~s", ["hello world"], 10))),
+ ?assertEqual("hello world\r\n", lists:flatten(format("~s", ["hello world\r\n"], 50))),
+ ?assertEqual("\rhello world\r\n", lists:flatten(format("~s", ["\rhello world\r\n"], 50))),
+ ?assertEqual("\"\\rhello world\\r\\n\"", lists:flatten(format("~p", ["\rhello world\r\n"], 50))),
+ ?assertEqual("[13,104,101,108,108,111,32,119,111,114,108,100,13,10]", lists:flatten(format("~w", ["\rhello world\r\n"], 60))),
+ ?assertEqual("...", lists:flatten(format("~s", ["\rhello world\r\n"], 3))),
+ ?assertEqual("[22835963083295358096932575511191922182123945984,...]",
+ lists:flatten(format("~p", [
+ [22835963083295358096932575511191922182123945984,
+ 22835963083295358096932575511191922182123945984]], 9))),
+ ?assertEqual("[22835963083295358096932575511191922182123945984,...]",
+ lists:flatten(format("~p", [
+ [22835963083295358096932575511191922182123945984,
+ 22835963083295358096932575511191922182123945984]], 53))),
+ %%improper list
+ ?assertEqual("[1,2,3|4]", lists:flatten(format("~P", [[1|[2|[3|4]]], 5], 50))),
+ ?assertEqual("[1|1]", lists:flatten(format("~P", [[1|1], 5], 50))),
+ ?assertEqual("[9|9]", lists:flatten(format("~p", [[9|9]], 50))),
+ ok.
+
+iolist_printing_test() ->
+ ?assertEqual("iolist: HelloIamaniolist",
+ lists:flatten(format("iolist: ~s", [[$H, $e, $l, $l, $o, "I", ["am", [<<"an">>], [$i, $o, $l, $i, $s, $t]]]], 1000))),
+ ?assertEqual("123...",
+ lists:flatten(format("~s", [[<<"123456789">>, "HellIamaniolist"]], 6))),
+ ?assertEqual("123456...",
+ lists:flatten(format("~s", [[<<"123456789">>, "HellIamaniolist"]], 9))),
+ ?assertEqual("123456789H...",
+ lists:flatten(format("~s", [[<<"123456789">>, "HellIamaniolist"]], 13))),
+ ?assertEqual("123456789HellIamaniolist",
+ lists:flatten(format("~s", [[<<"123456789">>, "HellIamaniolist"]], 30))),
+
+ ok.
+
+tuple_printing_test() ->
+ ?assertEqual("{}", lists:flatten(format("~p", [{}], 50))),
+ ?assertEqual("{}", lists:flatten(format("~w", [{}], 50))),
+ ?assertError(badarg, lists:flatten(format("~s", [{}], 50))),
+ ?assertEqual("{...}", lists:flatten(format("~p", [{foo}], 1))),
+ ?assertEqual("{...}", lists:flatten(format("~p", [{foo}], 2))),
+ ?assertEqual("{...}", lists:flatten(format("~p", [{foo}], 3))),
+ ?assertEqual("{...}", lists:flatten(format("~p", [{foo}], 4))),
+ ?assertEqual("{...}", lists:flatten(format("~p", [{foo}], 5))),
+ ?assertEqual("{foo,...}", lists:flatten(format("~p", [{foo,bar}], 6))),
+ ?assertEqual("{foo,...}", lists:flatten(format("~p", [{foo,bar}], 7))),
+ ?assertEqual("{foo,...}", lists:flatten(format("~p", [{foo,bar}], 9))),
+ ?assertEqual("{foo,bar}", lists:flatten(format("~p", [{foo,bar}], 10))),
+ ?assertEqual("{22835963083295358096932575511191922182123945984,...}",
+ lists:flatten(format("~w", [
+ {22835963083295358096932575511191922182123945984,
+ 22835963083295358096932575511191922182123945984}], 10))),
+ ?assertEqual("{22835963083295358096932575511191922182123945984,...}",
+ lists:flatten(format("~w", [
+ {22835963083295358096932575511191922182123945984,
+ bar}], 10))),
+ ?assertEqual("{22835963083295358096932575511191922182123945984,...}",
+ lists:flatten(format("~w", [
+ {22835963083295358096932575511191922182123945984,
+ 22835963083295358096932575511191922182123945984}], 53))),
+ ok.
+
+map_printing_test() ->
+ ?assertEqual("#{}", lists:flatten(format("~p", [maps:new()], 50))),
+ ?assertEqual("#{}", lists:flatten(format("~p", [maps:new()], 3))),
+ ?assertEqual("#{}", lists:flatten(format("~w", [maps:new()], 50))),
+ ?assertError(badarg, lists:flatten(format("~s", [maps:new()], 50))),
+ ?assertEqual("#{...}", lists:flatten(format("~p", [maps:from_list([{bar, foo}])], 1))),
+ ?assertEqual("#{...}", lists:flatten(format("~p", [maps:from_list([{bar, foo}])], 6))),
+ ?assertEqual("#{bar => ...}", lists:flatten(format("~p", [maps:from_list([{bar, foo}])], 7))),
+ ?assertEqual("#{bar => ...}", lists:flatten(format("~p", [maps:from_list([{bar, foo}])], 9))),
+ ?assertEqual("#{bar => foo}", lists:flatten(format("~p", [maps:from_list([{bar, foo}])], 10))),
+ ?assertEqual("#{bar => ...,...}", lists:flatten(format("~p", [maps:from_list([{bar, foo}, {foo, bar}])], 9))),
+ ?assertEqual("#{bar => foo,...}", lists:flatten(format("~p", [maps:from_list([{bar, foo}, {foo, bar}])], 10))),
+ ?assertEqual("#{bar => foo,...}", lists:flatten(format("~p", [maps:from_list([{bar, foo}, {foo, bar}])], 17))),
+ ?assertEqual("#{bar => foo,foo => ...}", lists:flatten(format("~p", [maps:from_list([{bar, foo}, {foo, bar}])], 18))),
+ ?assertEqual("#{bar => foo,foo => ...}", lists:flatten(format("~p", [maps:from_list([{bar, foo}, {foo, bar}])], 19))),
+ ?assertEqual("#{bar => foo,foo => ...}", lists:flatten(format("~p", [maps:from_list([{bar, foo}, {foo, bar}])], 20))),
+ ?assertEqual("#{bar => foo,foo => bar}", lists:flatten(format("~p", [maps:from_list([{bar, foo}, {foo, bar}])], 21))),
+ ?assertEqual("#{22835963083295358096932575511191922182123945984 => ...}",
+ lists:flatten(format("~w", [
+ maps:from_list([{22835963083295358096932575511191922182123945984,
+ 22835963083295358096932575511191922182123945984}])], 10))),
+ ?assertEqual("#{22835963083295358096932575511191922182123945984 => ...}",
+ lists:flatten(format("~w", [
+ maps:from_list([{22835963083295358096932575511191922182123945984,
+ bar}])], 10))),
+ ?assertEqual("#{22835963083295358096932575511191922182123945984 => ...}",
+ lists:flatten(format("~w", [
+ maps:from_list([{22835963083295358096932575511191922182123945984,
+ bar}])], 53))),
+ ?assertEqual("#{22835963083295358096932575511191922182123945984 => bar}",
+ lists:flatten(format("~w", [
+ maps:from_list([{22835963083295358096932575511191922182123945984,
+ bar}])], 54))),
+ ok.
+
+unicode_test() ->
+ ?assertEqual([231,167,129], lists:flatten(format("~s", [<<231,167,129>>], 50))),
+ ?assertEqual([31169], lists:flatten(format("~ts", [<<231,167,129>>], 50))),
+ ok.
+
+depth_limit_test() ->
+ ?assertEqual("{...}", lists:flatten(format("~P", [{a, [b, [c, [d]]]}, 1], 50))),
+ ?assertEqual("{a,...}", lists:flatten(format("~P", [{a, [b, [c, [d]]]}, 2], 50))),
+ ?assertEqual("{a,[...]}", lists:flatten(format("~P", [{a, [b, [c, [d]]]}, 3], 50))),
+ ?assertEqual("{a,[b|...]}", lists:flatten(format("~P", [{a, [b, [c, [d]]]}, 4], 50))),
+ ?assertEqual("{a,[b,[...]]}", lists:flatten(format("~P", [{a, [b, [c, [d]]]}, 5], 50))),
+ ?assertEqual("{a,[b,[c|...]]}", lists:flatten(format("~P", [{a, [b, [c, [d]]]}, 6], 50))),
+ ?assertEqual("{a,[b,[c,[...]]]}", lists:flatten(format("~P", [{a, [b, [c, [d]]]}, 7], 50))),
+ ?assertEqual("{a,[b,[c,[d]]]}", lists:flatten(format("~P", [{a, [b, [c, [d]]]}, 8], 50))),
+ ?assertEqual("{a,[b,[c,[d]]]}", lists:flatten(format("~P", [{a, [b, [c, [d]]]}, 9], 50))),
+
+ ?assertEqual("{a,{...}}", lists:flatten(format("~P", [{a, {b, {c, {d}}}}, 3], 50))),
+ ?assertEqual("{a,{b,...}}", lists:flatten(format("~P", [{a, {b, {c, {d}}}}, 4], 50))),
+ ?assertEqual("{a,{b,{...}}}", lists:flatten(format("~P", [{a, {b, {c, {d}}}}, 5], 50))),
+ ?assertEqual("{a,{b,{c,...}}}", lists:flatten(format("~P", [{a, {b, {c, {d}}}}, 6], 50))),
+ ?assertEqual("{a,{b,{c,{...}}}}", lists:flatten(format("~P", [{a, {b, {c, {d}}}}, 7], 50))),
+ ?assertEqual("{a,{b,{c,{d}}}}", lists:flatten(format("~P", [{a, {b, {c, {d}}}}, 8], 50))),
+
+ ?assertEqual("#{a => #{...}}",
+ lists:flatten(format("~P",
+ [maps:from_list([{a, maps:from_list([{b, maps:from_list([{c, d}])}])}]), 2], 50))),
+ ?assertEqual("#{a => #{b => #{...}}}",
+ lists:flatten(format("~P",
+ [maps:from_list([{a, maps:from_list([{b, maps:from_list([{c, d}])}])}]), 3], 50))),
+ ?assertEqual("#{a => #{b => #{c => d}}}",
+ lists:flatten(format("~P",
+ [maps:from_list([{a, maps:from_list([{b, maps:from_list([{c, d}])}])}]), 4], 50))),
+
+ ?assertEqual("#{}", lists:flatten(format("~P", [maps:new(), 1], 50))),
+ ?assertEqual("#{...}", lists:flatten(format("~P", [maps:from_list([{1,1}, {2,2}, {3,3}]), 1], 50))),
+ ?assertEqual("#{1 => 1,...}", lists:flatten(format("~P", [maps:from_list([{1,1}, {2,2}, {3,3}]), 2], 50))),
+ ?assertEqual("#{1 => 1,2 => 2,...}", lists:flatten(format("~P", [maps:from_list([{1,1}, {2,2}, {3,3}]), 3], 50))),
+ ?assertEqual("#{1 => 1,2 => 2,3 => 3}", lists:flatten(format("~P", [maps:from_list([{1,1}, {2,2}, {3,3}]), 4], 50))),
+
+ ?assertEqual("{\"a\",[...]}", lists:flatten(format("~P", [{"a", ["b", ["c", ["d"]]]}, 3], 50))),
+ ?assertEqual("{\"a\",[\"b\",[[...]|...]]}", lists:flatten(format("~P", [{"a", ["b", ["c", ["d"]]]}, 6], 50))),
+ ?assertEqual("{\"a\",[\"b\",[\"c\",[\"d\"]]]}", lists:flatten(format("~P", [{"a", ["b", ["c", ["d"]]]}, 9], 50))),
+
+ ?assertEqual("[...]", lists:flatten(format("~P", [[1, 2, 3], 1], 50))),
+ ?assertEqual("[1|...]", lists:flatten(format("~P", [[1, 2, 3], 2], 50))),
+ ?assertEqual("[1,2|...]", lists:flatten(format("~P", [[1, 2, 3], 3], 50))),
+ ?assertEqual("[1,2,3]", lists:flatten(format("~P", [[1, 2, 3], 4], 50))),
+
+ ?assertEqual("{1,...}", lists:flatten(format("~P", [{1, 2, 3}, 2], 50))),
+ ?assertEqual("{1,2,...}", lists:flatten(format("~P", [{1, 2, 3}, 3], 50))),
+ ?assertEqual("{1,2,3}", lists:flatten(format("~P", [{1, 2, 3}, 4], 50))),
+
+ ?assertEqual("{1,...}", lists:flatten(format("~P", [{1, 2, 3}, 2], 50))),
+ ?assertEqual("[1,2|...]", lists:flatten(format("~P", [[1, 2, <<3>>], 3], 50))),
+ ?assertEqual("[1,2,<<...>>]", lists:flatten(format("~P", [[1, 2, <<3>>], 4], 50))),
+ ?assertEqual("[1,2,<<3>>]", lists:flatten(format("~P", [[1, 2, <<3>>], 5], 50))),
+
+ ?assertEqual("<<...>>", lists:flatten(format("~P", [<<0, 0, 0, 0>>, 1], 50))),
+ ?assertEqual("<<0,...>>", lists:flatten(format("~P", [<<0, 0, 0, 0>>, 2], 50))),
+ ?assertEqual("<<0,0,...>>", lists:flatten(format("~P", [<<0, 0, 0, 0>>, 3], 50))),
+ ?assertEqual("<<0,0,0,...>>", lists:flatten(format("~P", [<<0, 0, 0, 0>>, 4], 50))),
+ ?assertEqual("<<0,0,0,0>>", lists:flatten(format("~P", [<<0, 0, 0, 0>>, 5], 50))),
+
+ %% this is a seriously weird edge case
+ ?assertEqual("<<\" \"...>>", lists:flatten(format("~P", [<<32, 32, 32, 0>>, 2], 50))),
+ ?assertEqual("<<\" \"...>>", lists:flatten(format("~P", [<<32, 32, 32, 0>>, 3], 50))),
+ ?assertEqual("<<\" \"...>>", lists:flatten(format("~P", [<<32, 32, 32, 0>>, 4], 50))),
+ ?assertEqual("<<32,32,32,0>>", lists:flatten(format("~P", [<<32, 32, 32, 0>>, 5], 50))),
+ ?assertEqual("<<32,32,32,0>>", lists:flatten(format("~p", [<<32, 32, 32, 0>>], 50))),
+
+ %% depth limiting for some reason works in 4 byte chunks on printable binaries?
+ ?assertEqual("<<\"hell\"...>>", lists:flatten(format("~P", [<<"hello world">>, 2], 50))),
+ ?assertEqual("<<\"abcd\"...>>", lists:flatten(format("~P", [<<$a, $b, $c, $d, $e, 0>>, 2], 50))),
+
+ %% I don't even know...
+ ?assertEqual("<<>>", lists:flatten(format("~P", [<<>>, 1], 50))),
+ ?assertEqual("<<>>", lists:flatten(format("~W", [<<>>, 1], 50))),
+
+ ?assertEqual("{abc,<<\"abc\\\"\">>}", lists:flatten(format("~P", [{abc,<<"abc\"">>}, 4], 50))),
+
+ ok.
+
+print_terms_without_format_string_test() ->
+ ?assertError(badarg, format({hello, world}, [], 50)),
+ ?assertError(badarg, format([{google, bomb}], [], 50)),
+ ?assertEqual([$h,$e,$l,$l,$o, 3594], format([$h,$e,$l,$l,$o, 3594], [], 50)),
+ ?assertError(badarg, format([$h,$e,$l,$l,$o, 65535], [], 50)),
+ ?assertEqual("helloworld", lists:flatten(format([$h,$e,$l,$l,$o, "world"], [], 50))),
+ ?assertEqual("hello", lists:flatten(format(<<"hello">>, [], 50))),
+ ?assertEqual("hello", lists:flatten(format('hello', [], 50))),
+ ?assertError(badarg, format(<<1, 2, 3, 1:7>>, [], 100)),
+ ?assertError(badarg, format(65535, [], 50)),
+ ok.
+
+improper_io_list_test() ->
+ ?assertEqual(">hello", lists:flatten(format('~s', [[$>|<<"hello">>]], 50))),
+ ?assertEqual(">hello", lists:flatten(format('~ts', [[$>|<<"hello">>]], 50))),
+ ?assertEqual("helloworld", lists:flatten(format('~ts', [[<<"hello">>|<<"world">>]], 50))),
+ ok.
+
+-endif.

guam-0.9.11.tar.gz/_checkouts/lager/src/lager_util.erl Added

@@ -0,0 +1,962 @@
+%% -------------------------------------------------------------------
+%%
+%% Copyright (c) 2011-2017 Basho Technologies, Inc.
+%%
+%% This file is provided to you 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.
+%%
+%% -------------------------------------------------------------------
+
+-module(lager_util).
+
+-export([
+ levels/0, level_to_num/1, level_to_chr/1,
+ num_to_level/1, config_to_mask/1, config_to_levels/1, mask_to_levels/1,
+ format_time/0, format_time/1,
+ localtime_ms/0, localtime_ms/1, maybe_utc/1, parse_rotation_date_spec/1,
+ calculate_next_rotation/1, validate_trace/1, check_traces/4, is_loggable/3,
+ trace_filter/1, trace_filter/2, expand_path/1, find_file/2, check_hwm/1, check_hwm/2,
+ make_internal_sink_name/1, otp_version/0, maybe_flush/2,
+ has_file_changed/3
+]).
+
+-ifdef(TEST).
+-export([create_test_dir/0, get_test_dir/0, delete_test_dir/0,
+ set_dir_permissions/2,
+ safe_application_load/1,
+ safe_write_file/2]).
+-include_lib("eunit/include/eunit.hrl").
+-endif.
+
+-include("lager.hrl").
+
+-include_lib("kernel/include/file.hrl").
+
+levels() ->
+ [debug, info, notice, warning, error, critical, alert, emergency, none].
+
+level_to_num(debug) -> ?DEBUG;
+level_to_num(info) -> ?INFO;
+level_to_num(notice) -> ?NOTICE;
+level_to_num(warning) -> ?WARNING;
+level_to_num(error) -> ?ERROR;
+level_to_num(critical) -> ?CRITICAL;
+level_to_num(alert) -> ?ALERT;
+level_to_num(emergency) -> ?EMERGENCY;
+level_to_num(none) -> ?LOG_NONE.
+
+level_to_chr(debug) -> $D;
+level_to_chr(info) -> $I;
+level_to_chr(notice) -> $N;
+level_to_chr(warning) -> $W;
+level_to_chr(error) -> $E;
+level_to_chr(critical) -> $C;
+level_to_chr(alert) -> $A;
+level_to_chr(emergency) -> $M;
+level_to_chr(none) -> $ .
+
+num_to_level(?DEBUG) -> debug;
+num_to_level(?INFO) -> info;
+num_to_level(?NOTICE) -> notice;
+num_to_level(?WARNING) -> warning;
+num_to_level(?ERROR) -> error;
+num_to_level(?CRITICAL) -> critical;
+num_to_level(?ALERT) -> alert;
+num_to_level(?EMERGENCY) -> emergency;
+num_to_level(?LOG_NONE) -> none.
+
+-spec config_to_mask(atom()|string()) -> {'mask', integer()}.
+config_to_mask(Conf) ->
+ Levels = config_to_levels(Conf),
+ {mask, lists:foldl(fun(Level, Acc) ->
+ level_to_num(Level) bor Acc
+ end, 0, Levels)}.
+
+-spec mask_to_levels(non_neg_integer()) -> [lager:log_level()].
+mask_to_levels(Mask) ->
+ mask_to_levels(Mask, levels(), []).
+
+mask_to_levels(_Mask, [], Acc) ->
+ lists:reverse(Acc);
+mask_to_levels(Mask, [Level|Levels], Acc) ->
+ NewAcc = case (level_to_num(Level) band Mask) /= 0 of
+ true ->
+ [Level|Acc];
+ false ->
+ Acc
+ end,
+ mask_to_levels(Mask, Levels, NewAcc).
+
+-spec config_to_levels(atom()|string()) -> [lager:log_level()].
+config_to_levels(Conf) when is_atom(Conf) ->
+ config_to_levels(atom_to_list(Conf));
+config_to_levels([$! | Rest]) ->
+ levels() -- config_to_levels(Rest);
+config_to_levels([$=, $< | Rest]) ->
+ [_|Levels] = config_to_levels_int(Rest),
+ lists:filter(fun(E) -> not lists:member(E, Levels) end, levels());
+config_to_levels([$<, $= | Rest]) ->
+ [_|Levels] = config_to_levels_int(Rest),
+ lists:filter(fun(E) -> not lists:member(E, Levels) end, levels());
+config_to_levels([$>, $= | Rest]) ->
+ config_to_levels_int(Rest);
+config_to_levels([$=, $> | Rest]) ->
+ config_to_levels_int(Rest);
+config_to_levels([$= | Rest]) ->
+ [level_to_atom(Rest)];
+config_to_levels([$< | Rest]) ->
+ Levels = config_to_levels_int(Rest),
+ lists:filter(fun(E) -> not lists:member(E, Levels) end, levels());
+config_to_levels([$> | Rest]) ->
+ [_|Levels] = config_to_levels_int(Rest),
+ lists:filter(fun(E) -> lists:member(E, Levels) end, levels());
+config_to_levels(Conf) ->
+ config_to_levels_int(Conf).
+
+%% internal function to break the recursion loop
+config_to_levels_int(Conf) ->
+ Level = level_to_atom(Conf),
+ lists:dropwhile(fun(E) -> E /= Level end, levels()).
+
+level_to_atom(String) ->
+ Levels = levels(),
+ try list_to_existing_atom(String) of
+ Atom ->
+ case lists:member(Atom, Levels) of
+ true ->
+ Atom;
+ false ->
+ erlang:error(badarg)
+ end
+ catch
+ _:_ ->
+ erlang:error(badarg)
+ end.
+
+%% returns localtime with milliseconds included
+localtime_ms() ->
+ Now = os:timestamp(),
+ localtime_ms(Now).
+
+localtime_ms(Now) ->
+ {_, _, Micro} = Now,
+ {Date, {Hours, Minutes, Seconds}} = calendar:now_to_local_time(Now),
+ {Date, {Hours, Minutes, Seconds, Micro div 1000 rem 1000}}.
+
+
+maybe_utc({Date, {H, M, S, Ms}}) ->
+ case lager_stdlib:maybe_utc({Date, {H, M, S}}) of
+ {utc, {Date1, {H1, M1, S1}}} ->
+ {utc, {Date1, {H1, M1, S1, Ms}}};
+ {Date1, {H1, M1, S1}} ->
+ {Date1, {H1, M1, S1, Ms}}
+ end.
+
+format_time() ->
+ format_time(maybe_utc(localtime_ms())).
+
+format_time({utc, {{Y, M, D}, {H, Mi, S, Ms}}}) ->
+ {[integer_to_list(Y), $-, i2l(M), $-, i2l(D)],
+ [i2l(H), $:, i2l(Mi), $:, i2l(S), $., i3l(Ms), $ , $U, $T, $C]};
+format_time({{Y, M, D}, {H, Mi, S, Ms}}) ->
+ {[integer_to_list(Y), $-, i2l(M), $-, i2l(D)],
+ [i2l(H), $:, i2l(Mi), $:, i2l(S), $., i3l(Ms)]};
+format_time({utc, {{Y, M, D}, {H, Mi, S}}}) ->
+ {[integer_to_list(Y), $-, i2l(M), $-, i2l(D)],
+ [i2l(H), $:, i2l(Mi), $:, i2l(S), $ , $U, $T, $C]};
+format_time({{Y, M, D}, {H, Mi, S}}) ->
+ {[integer_to_list(Y), $-, i2l(M), $-, i2l(D)],
+ [i2l(H), $:, i2l(Mi), $:, i2l(S)]}.
+
+parse_rotation_hour_spec([], Res) ->
+ {ok, Res};
+parse_rotation_hour_spec([$H, M1, M2], Res) ->
+ case list_to_integer([M1, M2]) of
+ X when X >= 0, X =< 59 ->
+ {ok, Res ++ [{minute, X}]};
+ _ ->
+ {error, invalid_date_spec}
+ end;
+parse_rotation_hour_spec([$H, M], Res) when M >= $0, M =< $9 ->
+ {ok, Res ++ [{minute, M - 48}]};
+parse_rotation_hour_spec(_,_) ->
+ {error, invalid_date_spec}.
+
+%% Default to 00:00:00 rotation
+parse_rotation_day_spec([], Res) ->
+ {ok, Res ++ [{hour ,0}]};
+parse_rotation_day_spec([$D, D1, D2|T], Res) ->
+ case list_to_integer([D1, D2]) of
+ X when X >= 0, X =< 23 ->
+ parse_rotation_hour_spec(T, Res ++ [{hour, X}]);
+ _ ->
+ {error, invalid_date_spec}
+ end;
+parse_rotation_day_spec([$D, D|T], Res) when D >= $0, D =< $9 ->
+ parse_rotation_hour_spec(T, Res ++ [{hour, D - 48 }]);
+parse_rotation_day_spec(X, Res) ->
+ parse_rotation_hour_spec(X, Res).
+
+parse_rotation_date_spec([$$, $W, W|T]) when W >= $0, W =< $6 ->
+ Week = W - 48,
+ parse_rotation_day_spec(T, [{day, Week}]);
+parse_rotation_date_spec([$$, $M, L|T]) when L == $L; L == $l ->
+ %% last day in month.
+ parse_rotation_day_spec(T, [{date, last}]);
+parse_rotation_date_spec([$$, $M, M1, M2|[$D|_]=T]) ->
+ case list_to_integer([M1, M2]) of
+ X when X >= 1, X =< 31 ->
+ parse_rotation_day_spec(T, [{date, X}]);
+ _ ->
+ {error, invalid_date_spec}
+ end;
+parse_rotation_date_spec([$$, $M, M|[$D|_]=T]) ->
+ parse_rotation_day_spec(T, [{date, M - 48}]);
+parse_rotation_date_spec([$$, $M, M1, M2]) ->
+ case list_to_integer([M1, M2]) of
+ X when X >= 1, X =< 31 ->
+ {ok, [{date, X}, {hour, 0}]};
+ _ ->
+ {error, invalid_date_spec}
+ end;
+parse_rotation_date_spec([$$, $M, M]) ->
+ {ok, [{date, M - 48}, {hour, 0}]};
+parse_rotation_date_spec([$$|X]) when X /= [] ->
+ parse_rotation_day_spec(X, []);
+parse_rotation_date_spec(_) ->
+ {error, invalid_date_spec}.
+
+calculate_next_rotation(Spec) ->
+ Now = calendar:local_time(),
+ Later = calculate_next_rotation(Spec, Now),
+ calendar:datetime_to_gregorian_seconds(Later) -
+ calendar:datetime_to_gregorian_seconds(Now).
+
+calculate_next_rotation([], Now) ->
+ Now;
+calculate_next_rotation([{minute, X}|T], {{_, _, _}, {Hour, Minute, _}} = Now) when Minute < X ->
+ %% rotation is this hour
+ NewNow = setelement(2, Now, {Hour, X, 0}),
+ calculate_next_rotation(T, NewNow);
+calculate_next_rotation([{minute, X}|T], Now) ->
+ %% rotation is next hour
+ Seconds = calendar:datetime_to_gregorian_seconds(Now) + 3600,
+ DateTime = calendar:gregorian_seconds_to_datetime(Seconds),
+ {_, {NewHour, _, _}} = DateTime,
+ NewNow = setelement(2, DateTime, {NewHour, X, 0}),
+ calculate_next_rotation(T, NewNow);
+calculate_next_rotation([{hour, X}|T], {{_, _, _}, {Hour, _, _}} = Now) when Hour < X ->
+ %% rotation is today, sometime
+ NewNow = setelement(2, Now, {X, 0, 0}),
+ calculate_next_rotation(T, NewNow);
+calculate_next_rotation([{hour, X}|T], {{_, _, _}, _} = Now) ->
+ %% rotation is not today
+ Seconds = calendar:datetime_to_gregorian_seconds(Now) + 86400,
+ DateTime = calendar:gregorian_seconds_to_datetime(Seconds),
+ NewNow = setelement(2, DateTime, {X, 0, 0}),
+ calculate_next_rotation(T, NewNow);
+calculate_next_rotation([{day, Day}|T], {Date, _Time} = Now) ->
+ DoW = calendar:day_of_the_week(Date),
+ AdjustedDay = case Day of
+ 0 -> 7;
+ X -> X
+ end,
+ case AdjustedDay of
+ DoW -> %% rotation is today
+ case calculate_next_rotation(T, Now) of
+ {Date, _} = NewNow -> NewNow;
+ {NewDate, _} ->
+ %% rotation *isn't* today! rerun the calculation
+ NewNow = {NewDate, {0, 0, 0}},
+ calculate_next_rotation([{day, Day}|T], NewNow)
+ end;
+ Y when Y > DoW -> %% rotation is later this week
+ PlusDays = Y - DoW,
+ Seconds = calendar:datetime_to_gregorian_seconds(Now) + (86400 * PlusDays),
+ {NewDate, _} = calendar:gregorian_seconds_to_datetime(Seconds),
+ NewNow = {NewDate, {0, 0, 0}},
+ calculate_next_rotation(T, NewNow);
+ Y when Y < DoW -> %% rotation is next week
+ PlusDays = ((7 - DoW) + Y),
+ Seconds = calendar:datetime_to_gregorian_seconds(Now) + (86400 * PlusDays),
+ {NewDate, _} = calendar:gregorian_seconds_to_datetime(Seconds),
+ NewNow = {NewDate, {0, 0, 0}},
+ calculate_next_rotation(T, NewNow)
+ end;
+calculate_next_rotation([{date, last}|T], {{Year, Month, Day}, _} = Now) ->
+ Last = calendar:last_day_of_the_month(Year, Month),
+ case Last == Day of
+ true -> %% doing rotation today
+ case calculate_next_rotation(T, Now) of
+ {{Year, Month, Day}, _} = NewNow -> NewNow;
+ {NewDate, _} ->
+ %% rotation *isn't* today! rerun the calculation
+ NewNow = {NewDate, {0, 0, 0}},
+ calculate_next_rotation([{date, last}|T], NewNow)
+ end;
+ false ->
+ NewNow = setelement(1, Now, {Year, Month, Last}),
+ calculate_next_rotation(T, NewNow)
+ end;
+calculate_next_rotation([{date, Date}|T], {{Year, Month, Date}, _} = Now) ->
+ %% rotation is today
+ case calculate_next_rotation(T, Now) of
+ {{Year, Month, Date}, _} = NewNow -> NewNow;
+ {NewDate, _} ->
+ %% rotation *isn't* today! rerun the calculation
+ NewNow = setelement(1, Now, NewDate),
+ calculate_next_rotation([{date, Date}|T], NewNow)
+ end;
+calculate_next_rotation([{date, Date}|T], {{Year, Month, Day}, _} = Now) ->
+ PlusDays = case Date of
+ X when X < Day -> %% rotation is next month
+ Last = calendar:last_day_of_the_month(Year, Month),
+ (Last - Day);
+ X when X > Day -> %% rotation is later this month
+ X - Day
+ end,
+ Seconds = calendar:datetime_to_gregorian_seconds(Now) + (86400 * PlusDays),
+ NewNow = calendar:gregorian_seconds_to_datetime(Seconds),
+ calculate_next_rotation(T, NewNow).
+
+-spec trace_filter(Query :: 'none' | [tuple()]) -> {ok, any()}.
+trace_filter(Query) ->
+ trace_filter(?DEFAULT_TRACER, Query).
+
+%% TODO: Support multiple trace modules
+%-spec trace_filter(Module :: atom(), Query :: 'none' | [tuple()]) -> {ok, any()}.
+trace_filter(Module, Query) when Query == none; Query == [] ->
+ {ok, _} = glc:compile(Module, glc:null(false));
+trace_filter(Module, Query) when is_list(Query) ->
+ {ok, _} = glc:compile(Module, glc_lib:reduce(trace_any(Query))).
+
+validate_trace({Filter, Level, {Destination, ID}}) when is_tuple(Filter); is_list(Filter), is_atom(Level), is_atom(Destination) ->
+ case validate_trace({Filter, Level, Destination}) of
+ {ok, {F, L, D}} ->
+ {ok, {F, L, {D, ID}}};
+ Error ->
+ Error
+ end;
+validate_trace({Filter, Level, Destination}) when is_tuple(Filter); is_list(Filter), is_atom(Level), is_atom(Destination) ->
+ ValidFilter = validate_trace_filter(Filter),
+ try config_to_mask(Level) of
+ _ when not ValidFilter ->
+ {error, invalid_trace};
+ L when is_list(Filter) ->
+ {ok, {trace_all(Filter), L, Destination}};
+ L ->
+ {ok, {Filter, L, Destination}}
+ catch
+ _:_ ->
+ {error, invalid_level}
+ end;
+validate_trace(_) ->
+ {error, invalid_trace}.
+
+validate_trace_filter(Filter) when is_tuple(Filter), is_atom(element(1, Filter)) =:= false ->
+ false;
+validate_trace_filter(Filter) when is_list(Filter) ->
+ lists:all(fun validate_trace_filter/1, Filter);
+validate_trace_filter({Key, '*'}) when is_atom(Key) -> true;
+validate_trace_filter({any, L}) when is_list(L) -> lists:all(fun validate_trace_filter/1, L);
+validate_trace_filter({all, L}) when is_list(L) -> lists:all(fun validate_trace_filter/1, L);
+validate_trace_filter({null, Bool}) when is_boolean(Bool) -> true;
+validate_trace_filter({Key, _Value}) when is_atom(Key) -> true;
+validate_trace_filter({Key, '=', _Value}) when is_atom(Key) -> true;
+validate_trace_filter({Key, '!=', _Value}) when is_atom(Key) -> true;
+validate_trace_filter({Key, '<', _Value}) when is_atom(Key) -> true;
+validate_trace_filter({Key, '=<', _Value}) when is_atom(Key) -> true;
+validate_trace_filter({Key, '>', _Value}) when is_atom(Key) -> true;
+validate_trace_filter({Key, '>=', _Value}) when is_atom(Key) -> true;
+validate_trace_filter(_) -> false.
+
+trace_all(Query) ->
+ glc:all(trace_acc(Query)).
+
+trace_any(Query) ->
+ glc:any(Query).
+
+trace_acc(Query) ->
+ trace_acc(Query, []).
+
+trace_acc([], Acc) ->
+ lists:reverse(Acc);
+trace_acc([{any, L}|T], Acc) ->
+ trace_acc(T, [glc:any(L)|Acc]);
+trace_acc([{all, L}|T], Acc) ->
+ trace_acc(T, [glc:all(L)|Acc]);
+trace_acc([{null, Bool}|T], Acc) ->
+ trace_acc(T, [glc:null(Bool)|Acc]);
+trace_acc([{Key, '*'}|T], Acc) ->
+ trace_acc(T, [glc:wc(Key)|Acc]);
+trace_acc([{Key, '!'}|T], Acc) ->
+ trace_acc(T, [glc:nf(Key)|Acc]);
+trace_acc([{Key, Val}|T], Acc) ->
+ trace_acc(T, [glc:eq(Key, Val)|Acc]);
+trace_acc([{Key, '=', Val}|T], Acc) ->
+ trace_acc(T, [glc:eq(Key, Val)|Acc]);
+trace_acc([{Key, '!=', Val}|T], Acc) ->
+ trace_acc(T, [glc:neq(Key, Val)|Acc]);
+trace_acc([{Key, '>', Val}|T], Acc) ->
+ trace_acc(T, [glc:gt(Key, Val)|Acc]);
+trace_acc([{Key, '>=', Val}|T], Acc) ->
+ trace_acc(T, [glc:gte(Key, Val)|Acc]);
+trace_acc([{Key, '=<', Val}|T], Acc) ->
+ trace_acc(T, [glc:lte(Key, Val)|Acc]);
+trace_acc([{Key, '<', Val}|T], Acc) ->
+ trace_acc(T, [glc:lt(Key, Val)|Acc]).
+
+check_traces(_, _, [], Acc) ->
+ lists:flatten(Acc);
+check_traces(Attrs, Level, [{_, {mask, FilterLevel}, _}|Flows], Acc) when (Level band FilterLevel) == 0 ->
+ check_traces(Attrs, Level, Flows, Acc);
+check_traces(Attrs, Level, [{Filter, _, _}|Flows], Acc) when length(Attrs) < length(Filter) ->
+ check_traces(Attrs, Level, Flows, Acc);
+check_traces(Attrs, Level, [Flow|Flows], Acc) ->
+ check_traces(Attrs, Level, Flows, [check_trace(Attrs, Flow)|Acc]).
+
+check_trace(Attrs, {Filter, _Level, Dest}) when is_list(Filter) ->
+ check_trace(Attrs, {trace_all(Filter), _Level, Dest});
+
+check_trace(Attrs, {Filter, _Level, Dest}) when is_tuple(Filter) ->
+ Made = gre:make(Attrs, [list]),
+ glc:handle(?DEFAULT_TRACER, Made),
+ Match = glc_lib:matches(Filter, Made),
+ case Match of
+ true ->
+ Dest;
+ false ->
+ []
+ end.
+
+-spec is_loggable(lager_msg:lager_msg(), non_neg_integer()|{'mask', non_neg_integer()}, term()) -> boolean().
+is_loggable(Msg, {mask, Mask}, MyName) ->
+ %% using syslog style comparison flags
+ %S = lager_msg:severity_as_int(Msg),
+ %?debugFmt("comparing masks ~.2B and ~.2B -> ~p~n", [S, Mask, S band Mask]),
+ (lager_msg:severity_as_int(Msg) band Mask) /= 0 orelse
+ lists:member(MyName, lager_msg:destinations(Msg));
+is_loggable(Msg, SeverityThreshold, MyName) when is_atom(SeverityThreshold) ->
+ is_loggable(Msg, level_to_num(SeverityThreshold), MyName);
+is_loggable(Msg, SeverityThreshold, MyName) when is_integer(SeverityThreshold) ->
+ lager_msg:severity_as_int(Msg) =< SeverityThreshold orelse
+ lists:member(MyName, lager_msg:destinations(Msg)).
+
+i2l(I) when I < 10 -> [$0, $0+I];
+i2l(I) -> integer_to_list(I).
+i3l(I) when I < 100 -> [$0 | i2l(I)];
+i3l(I) -> integer_to_list(I).
+
+%% When log_root option is provided, get the real path to a file
+expand_path(LogPath) ->
+ LogRoot = application:get_env(lager, log_root, undefined),
+ RealPath = case filename:absname(LogPath) =:= LogPath of
+ false when LogRoot =/= undefined ->
+ filename:join(LogRoot, LogPath);
+ _ ->
+ LogPath
+ end,
+ %% see #534 make sure c:cd can't change file path, trans filename to abs name
+ filename:absname(RealPath).
+
+%% Find a file among the already installed handlers.
+%%
+%% The file is already expanded (i.e. lager_util:expand_path already added the
+%% "log_root"), but the file paths inside Handlers are not.
+find_file(_File1, _Handlers = []) ->
+ false;
+find_file(File1, [{{lager_file_backend, File2}, _Handler, _Sink} = HandlerInfo | Handlers]) ->
+ File1Abs = File1,
+ File2Abs = lager_util:expand_path(File2),
+ case File1Abs =:= File2Abs of
+ true ->
+ % The file inside HandlerInfo is the same as the file we are looking
+ % for, so we are done.
+ HandlerInfo;
+ false ->
+ find_file(File1, Handlers)
+ end;
+find_file(File1, [_HandlerInfo | Handlers]) ->
+ find_file(File1, Handlers).
+
+%% conditionally check the HWM if the event would not have been filtered
+check_hwm(Shaper = #lager_shaper{filter = Filter}, Event) ->
+ case Filter(Event) of
+ true ->
+ {true, 0, Shaper};
+ false ->
+ check_hwm(Shaper)
+ end.
+
+%% Log rate limit, i.e. high water mark for incoming messages
+
+check_hwm(Shaper = #lager_shaper{hwm = undefined}) ->
+ {true, 0, Shaper};
+check_hwm(Shaper = #lager_shaper{mps = Mps, hwm = Hwm, lasttime = Last}) when Mps < Hwm ->
+ {M, S, _} = Now = os:timestamp(),
+ case Last of
+ {M, S, _} ->
+ {true, 0, Shaper#lager_shaper{mps=Mps+1}};
+ _ ->
+ %different second - reset mps
+ {true, 0, Shaper#lager_shaper{mps=1, lasttime = Now}}
+ end;
+check_hwm(Shaper = #lager_shaper{lasttime = Last, dropped = Drop}) ->
+ %% are we still in the same second?
+ {M, S, _} = Now = os:timestamp(),
+ case Last of
+ {M, S, N} ->
+ %% still in same second, but have exceeded the high water mark
+ NewDrops = case should_flush(Shaper) of
+ true ->
+ discard_messages(Now, Shaper#lager_shaper.filter, 0);
+ false ->
+ 0
+ end,
+ Timer = case erlang:read_timer(Shaper#lager_shaper.timer) of
+ false ->
+ erlang:send_after(trunc((1000000 - N)/1000), self(), {shaper_expired, Shaper#lager_shaper.id});
+ _ ->
+ Shaper#lager_shaper.timer
+ end,
+ {false, 0, Shaper#lager_shaper{dropped=Drop+NewDrops, timer=Timer}};
+ _ ->
+ _ = erlang:cancel_timer(Shaper#lager_shaper.timer),
+ %% different second, reset all counters and allow it
+ {true, Drop, Shaper#lager_shaper{dropped = 0, mps=0, lasttime = Now}}
+ end.
+
+should_flush(#lager_shaper{flush_queue = true, flush_threshold = 0}) ->
+ true;
+should_flush(#lager_shaper{flush_queue = true, flush_threshold = T}) ->
+ {_, L} = process_info(self(), message_queue_len),
+ L > T;
+should_flush(_) ->
+ false.
+
+discard_messages(Second, Filter, Count) ->
+ {M, S, _} = os:timestamp(),
+ case Second of
+ {M, S, _} ->
+ receive
+ %% we only discard gen_event notifications, because
+ %% otherwise we might discard gen_event internal
+ %% messages, such as trapped EXITs
+ {notify, Event} ->
+ NewCount = case Filter(Event) of
+ false -> Count+1;
+ true -> Count
+ end,
+ discard_messages(Second, Filter, NewCount)
+ after 0 ->
+ Count
+ end;
+ _ ->
+ Count
+ end.
+
+%% @private Build an atom for the gen_event process based on a sink name.
+%% For historical reasons, the default gen_event process for lager itself is named
+%% `lager_event'. For all other sinks, it is SinkName++`_lager_event'
+make_internal_sink_name(lager) ->
+ ?DEFAULT_SINK;
+make_internal_sink_name(Sink) ->
+ list_to_atom(atom_to_list(Sink) ++ "_lager_event").
+
+-spec otp_version() -> pos_integer().
+%% @doc Return the major version of the current Erlang/OTP runtime as an integer.
+otp_version() ->
+ {Vsn, _} = string:to_integer(
+ case erlang:system_info(otp_release) of
+ [$R | Rel] ->
+ Rel;
+ Rel ->
+ Rel
+ end),
+ Vsn.
+
+maybe_flush(undefined, #lager_shaper{} = S) ->
+ S;
+maybe_flush(Flag, #lager_shaper{} = S) when is_boolean(Flag) ->
+ S#lager_shaper{flush_queue = Flag}.
+
+-spec has_file_changed(Name :: file:name_all(),
+ Inode0 :: pos_integer(),
+ Ctime0 :: file:date_time()) -> {boolean(), file:file_info() | undefined}.
+has_file_changed(Name, Inode0, Ctime0) ->
+ {OsType, _} = os:type(),
+ F = file:read_file_info(Name, [raw]),
+ case {OsType, F} of
+ {win32, {ok, #file_info{ctime=Ctime1}=FInfo}} ->
+ % Note: on win32, Inode is always zero
+ % So check the file's ctime to see if it
+ % needs to be re-opened
+ Changed = Ctime0 =/= Ctime1,
+ {Changed, FInfo};
+ {_, {ok, #file_info{inode=Inode1}=FInfo}} ->
+ Changed = Inode0 =/= Inode1,
+ {Changed, FInfo};
+ {_, _} ->
+ {true, undefined}
+ end.
+
+-ifdef(TEST).
+
+parse_test() ->
+ ?assertEqual({ok, [{minute, 0}]}, parse_rotation_date_spec("$H0")),
+ ?assertEqual({ok, [{minute, 59}]}, parse_rotation_date_spec("$H59")),
+ ?assertEqual({ok, [{hour, 0}]}, parse_rotation_date_spec("$D0")),
+ ?assertEqual({ok, [{hour, 23}]}, parse_rotation_date_spec("$D23")),
+ ?assertEqual({ok, [{day, 0}, {hour, 23}]}, parse_rotation_date_spec("$W0D23")),
+ ?assertEqual({ok, [{day, 5}, {hour, 16}]}, parse_rotation_date_spec("$W5D16")),
+ ?assertEqual({ok, [{day, 0}, {hour, 12}, {minute, 30}]}, parse_rotation_date_spec("$W0D12H30")),
+ ?assertEqual({ok, [{date, 1}, {hour, 0}]}, parse_rotation_date_spec("$M1D0")),
+ ?assertEqual({ok, [{date, 5}, {hour, 6}]}, parse_rotation_date_spec("$M5D6")),
+ ?assertEqual({ok, [{date, 5}, {hour, 0}]}, parse_rotation_date_spec("$M5")),
+ ?assertEqual({ok, [{date, 31}, {hour, 0}]}, parse_rotation_date_spec("$M31")),
+ ?assertEqual({ok, [{date, 31}, {hour, 1}]}, parse_rotation_date_spec("$M31D1")),
+ ?assertEqual({ok, [{date, last}, {hour, 0}]}, parse_rotation_date_spec("$ML")),
+ ?assertEqual({ok, [{date, last}, {hour, 0}]}, parse_rotation_date_spec("$Ml")),
+ ?assertEqual({ok, [{day, 5}, {hour, 0}]}, parse_rotation_date_spec("$W5")),
+ ok.
+
+parse_fail_test() ->
+ ?assertEqual({error, invalid_date_spec}, parse_rotation_date_spec("$H")),
+ ?assertEqual({error, invalid_date_spec}, parse_rotation_date_spec("$H60")),
+ ?assertEqual({error, invalid_date_spec}, parse_rotation_date_spec("$D")),
+ ?assertEqual({error, invalid_date_spec}, parse_rotation_date_spec("$D24")),
+ ?assertEqual({error, invalid_date_spec}, parse_rotation_date_spec("$W7")),
+ ?assertEqual({error, invalid_date_spec}, parse_rotation_date_spec("$W7D1")),
+ ?assertEqual({error, invalid_date_spec}, parse_rotation_date_spec("$M32")),
+ ?assertEqual({error, invalid_date_spec}, parse_rotation_date_spec("$M32D1")),
+ ?assertEqual({error, invalid_date_spec}, parse_rotation_date_spec("$")),
+ ?assertEqual({error, invalid_date_spec}, parse_rotation_date_spec("")),
+ ?assertEqual({error, invalid_date_spec}, parse_rotation_date_spec("$D15M5")),
+ ?assertEqual({error, invalid_date_spec}, parse_rotation_date_spec("$M5W5")),
+ ok.
+
+rotation_calculation_test() ->
+ ?assertMatch({{2000, 1, 1}, {13, 0, 0}},
+ calculate_next_rotation([{minute, 0}], {{2000, 1, 1}, {12, 34, 43}})),
+ ?assertMatch({{2000, 1, 1}, {12, 45, 0}},
+ calculate_next_rotation([{minute, 45}], {{2000, 1, 1}, {12, 34, 43}})),
+ ?assertMatch({{2000, 1, 2}, {0, 0, 0}},
+ calculate_next_rotation([{minute, 0}], {{2000, 1, 1}, {23, 45, 43}})),
+ ?assertMatch({{2000, 1, 2}, {0, 0, 0}},
+ calculate_next_rotation([{hour, 0}], {{2000, 1, 1}, {12, 34, 43}})),
+ ?assertMatch({{2000, 1, 1}, {16, 0, 0}},
+ calculate_next_rotation([{hour, 16}], {{2000, 1, 1}, {12, 34, 43}})),
+ ?assertMatch({{2000, 1, 2}, {12, 0, 0}},
+ calculate_next_rotation([{hour, 12}], {{2000, 1, 1}, {12, 34, 43}})),
+ ?assertMatch({{2000, 2, 1}, {12, 0, 0}},
+ calculate_next_rotation([{date, 1}, {hour, 12}], {{2000, 1, 1}, {12, 34, 43}})),
+ ?assertMatch({{2000, 2, 1}, {12, 0, 0}},
+ calculate_next_rotation([{date, 1}, {hour, 12}], {{2000, 1, 15}, {12, 34, 43}})),
+ ?assertMatch({{2000, 2, 1}, {12, 0, 0}},
+ calculate_next_rotation([{date, 1}, {hour, 12}], {{2000, 1, 2}, {12, 34, 43}})),
+ ?assertMatch({{2000, 2, 1}, {12, 0, 0}},
+ calculate_next_rotation([{date, 1}, {hour, 12}], {{2000, 1, 31}, {12, 34, 43}})),
+ ?assertMatch({{2000, 1, 1}, {16, 0, 0}},
+ calculate_next_rotation([{date, 1}, {hour, 16}], {{2000, 1, 1}, {12, 34, 43}})),
+ ?assertMatch({{2000, 1, 15}, {16, 0, 0}},
+ calculate_next_rotation([{date, 15}, {hour, 16}], {{2000, 1, 1}, {12, 34, 43}})),
+ ?assertMatch({{2000, 1, 31}, {16, 0, 0}},
+ calculate_next_rotation([{date, last}, {hour, 16}], {{2000, 1, 1}, {12, 34, 43}})),
+ ?assertMatch({{2000, 1, 31}, {16, 0, 0}},
+ calculate_next_rotation([{date, last}, {hour, 16}], {{2000, 1, 31}, {12, 34, 43}})),
+ ?assertMatch({{2000, 2, 29}, {16, 0, 0}},
+ calculate_next_rotation([{date, last}, {hour, 16}], {{2000, 1, 31}, {17, 34, 43}})),
+ ?assertMatch({{2001, 2, 28}, {16, 0, 0}},
+ calculate_next_rotation([{date, last}, {hour, 16}], {{2001, 1, 31}, {17, 34, 43}})),
+
+ ?assertMatch({{2000, 1, 1}, {16, 0, 0}},
+ calculate_next_rotation([{day, 6}, {hour, 16}], {{2000, 1, 1}, {12, 34, 43}})),
+ ?assertMatch({{2000, 1, 8}, {16, 0, 0}},
+ calculate_next_rotation([{day, 6}, {hour, 16}], {{2000, 1, 1}, {17, 34, 43}})),
+ ?assertMatch({{2000, 1, 7}, {16, 0, 0}},
+ calculate_next_rotation([{day, 5}, {hour, 16}], {{2000, 1, 1}, {17, 34, 43}})),
+ ?assertMatch({{2000, 1, 3}, {16, 0, 0}},
+ calculate_next_rotation([{day, 1}, {hour, 16}], {{2000, 1, 1}, {17, 34, 43}})),
+ ?assertMatch({{2000, 1, 2}, {16, 0, 0}},
+ calculate_next_rotation([{day, 0}, {hour, 16}], {{2000, 1, 1}, {17, 34, 43}})),
+ ?assertMatch({{2000, 1, 9}, {16, 0, 0}},
+ calculate_next_rotation([{day, 0}, {hour, 16}], {{2000, 1, 2}, {17, 34, 43}})),
+ ?assertMatch({{2000, 2, 3}, {16, 0, 0}},
+ calculate_next_rotation([{day, 4}, {hour, 16}], {{2000, 1, 29}, {17, 34, 43}})),
+
+ ?assertMatch({{2000, 1, 7}, {16, 0, 0}},
+ calculate_next_rotation([{day, 5}, {hour, 16}], {{2000, 1, 3}, {17, 34, 43}})),
+
+ ?assertMatch({{2000, 1, 3}, {16, 0, 0}},
+ calculate_next_rotation([{day, 1}, {hour, 16}], {{1999, 12, 28}, {17, 34, 43}})),
+ ok.
+
+check_trace_test() ->
+ lager:start(),
+ trace_filter(none),
+ %% match by module
+ ?assertEqual([foo], check_traces([{module, ?MODULE}], ?EMERGENCY, [
+ {[{module, ?MODULE}], config_to_mask(emergency), foo},
+ {[{module, test}], config_to_mask(emergency), bar}], [])),
+ %% match by module, but other unsatisfyable attribute
+ ?assertEqual([], check_traces([{module, ?MODULE}], ?EMERGENCY, [
+ {[{module, ?MODULE}, {foo, bar}], config_to_mask(emergency), foo},
+ {[{module, test}], config_to_mask(emergency), bar}], [])),
+ %% match by wildcard module
+ ?assertEqual([bar], check_traces([{module, ?MODULE}], ?EMERGENCY, [
+ {[{module, ?MODULE}, {foo, bar}], config_to_mask(emergency), foo},
+ {[{module, '*'}], config_to_mask(emergency), bar}], [])),
+ %% wildcard module, one trace with unsatisfyable attribute
+ ?assertEqual([bar], check_traces([{module, ?MODULE}], ?EMERGENCY, [
+ {[{module, '*'}, {foo, bar}], config_to_mask(emergency), foo},
+ {[{module, '*'}], config_to_mask(emergency), bar}], [])),
+ %% wildcard but not present custom trace attribute
+ ?assertEqual([bar], check_traces([{module, ?MODULE}], ?EMERGENCY, [
+ {[{module, '*'}, {foo, '*'}], config_to_mask(emergency), foo},
+ {[{module, '*'}], config_to_mask(emergency), bar}], [])),
+ %% wildcarding a custom attribute works when it is present
+ ?assertEqual([bar, foo], check_traces([{module, ?MODULE}, {foo, bar}], ?EMERGENCY, [
+ {[{module, '*'}, {foo, '*'}], config_to_mask(emergency), foo},
+ {[{module, '*'}], config_to_mask(emergency), bar}], [])),
+ %% denied by level
+ ?assertEqual([], check_traces([{module, ?MODULE}, {foo, bar}], ?INFO, [
+ {[{module, '*'}, {foo, '*'}], config_to_mask(emergency), foo},
+ {[{module, '*'}], config_to_mask(emergency), bar}], [])),
+ %% allowed by level
+ ?assertEqual([foo], check_traces([{module, ?MODULE}, {foo, bar}], ?INFO, [
+ {[{module, '*'}, {foo, '*'}], config_to_mask(debug), foo},
+ {[{module, '*'}], config_to_mask(emergency), bar}], [])),
+ ?assertEqual([anythingbutnotice, infoandbelow, infoonly], check_traces([{module, ?MODULE}], ?INFO, [
+ {[{module, '*'}], config_to_mask('=debug'), debugonly},
+ {[{module, '*'}], config_to_mask('=info'), infoonly},
+ {[{module, '*'}], config_to_mask('<=info'), infoandbelow},
+ {[{module, '*'}], config_to_mask('!=info'), anythingbutinfo},
+ {[{module, '*'}], config_to_mask('!=notice'), anythingbutnotice}
+ ], [])),
+ application:stop(lager),
+ application:stop(goldrush),
+ ok.
+
+is_loggable_test_() ->
+ [
+ {"Loggable by severity only", ?_assert(is_loggable(lager_msg:new("", alert, [], []),2,me))},
+ {"Not loggable by severity only", ?_assertNot(is_loggable(lager_msg:new("", critical, [], []),1,me))},
+ {"Loggable by severity with destination", ?_assert(is_loggable(lager_msg:new("", alert, [], [you]),2,me))},
+ {"Not loggable by severity with destination", ?_assertNot(is_loggable(lager_msg:new("", critical, [], [you]),1,me))},
+ {"Loggable by destination overriding severity", ?_assert(is_loggable(lager_msg:new("", critical, [], [me]),1,me))}
+ ].
+
+format_time_test_() ->
+ [
+ ?_assertEqual("2012-10-04 11:16:23.002",
+ begin
+ {D, T} = format_time({{2012,10,04},{11,16,23,2}}),
+ lists:flatten([D,$ ,T])
+ end),
+ ?_assertEqual("2012-10-04 11:16:23.999",
+ begin
+ {D, T} = format_time({{2012,10,04},{11,16,23,999}}),
+ lists:flatten([D,$ ,T])
+ end),
+ ?_assertEqual("2012-10-04 11:16:23",
+ begin
+ {D, T} = format_time({{2012,10,04},{11,16,23}}),
+ lists:flatten([D,$ ,T])
+ end),
+ ?_assertEqual("2012-10-04 00:16:23.092 UTC",
+ begin
+ {D, T} = format_time({utc, {{2012,10,04},{0,16,23,92}}}),
+ lists:flatten([D,$ ,T])
+ end),
+ ?_assertEqual("2012-10-04 11:16:23 UTC",
+ begin
+ {D, T} = format_time({utc, {{2012,10,04},{11,16,23}}}),
+ lists:flatten([D,$ ,T])
+ end)
+ ].
+
+config_to_levels_test() ->
+ ?assertEqual([none], config_to_levels('none')),
+ ?assertEqual({mask, 0}, config_to_mask('none')),
+ ?assertEqual([debug], config_to_levels('=debug')),
+ ?assertEqual([debug], config_to_levels('<info')),
+ ?assertEqual(levels() -- [debug], config_to_levels('!=debug')),
+ ?assertEqual(levels() -- [debug], config_to_levels('>debug')),
+ ?assertEqual(levels() -- [debug], config_to_levels('>=info')),
+ ?assertEqual(levels() -- [debug], config_to_levels('=>info')),
+ ?assertEqual([debug, info, notice], config_to_levels('<=notice')),
+ ?assertEqual([debug, info, notice], config_to_levels('=<notice')),
+ ?assertEqual([debug], config_to_levels('<info')),
+ ?assertEqual([debug], config_to_levels('!info')),
+ ?assertError(badarg, config_to_levels(ok)),
+ ?assertError(badarg, config_to_levels('<=>info')),
+ ?assertError(badarg, config_to_levels('=<=info')),
+ ?assertError(badarg, config_to_levels('<==>=<=>info')),
+ %% double negatives DO work, however
+ ?assertEqual([debug], config_to_levels('!!=debug')),
+ ?assertEqual(levels() -- [debug], config_to_levels('!!!=debug')),
+ ok.
+
+config_to_mask_test() ->
+ ?assertEqual({mask, 0}, config_to_mask('none')),
+ ?assertEqual({mask, ?DEBUG bor ?INFO bor ?NOTICE bor ?WARNING bor ?ERROR bor ?CRITICAL bor ?ALERT bor ?EMERGENCY}, config_to_mask('debug')),
+ ?assertEqual({mask, ?WARNING bor ?ERROR bor ?CRITICAL bor ?ALERT bor ?EMERGENCY}, config_to_mask('warning')),
+ ?assertEqual({mask, ?DEBUG bor ?NOTICE bor ?WARNING bor ?ERROR bor ?CRITICAL bor ?ALERT bor ?EMERGENCY}, config_to_mask('!=info')),
+ ok.
+
+mask_to_levels_test() ->
+ ?assertEqual([], mask_to_levels(0)),
+ ?assertEqual([debug], mask_to_levels(2#10000000)),
+ ?assertEqual([debug, info], mask_to_levels(2#11000000)),
+ ?assertEqual([debug, info, emergency], mask_to_levels(2#11000001)),
+ ?assertEqual([debug, notice, error], mask_to_levels(?DEBUG bor ?NOTICE bor ?ERROR)),
+ ok.
+
+expand_path_test() ->
+ OldRootVal = application:get_env(lager, log_root),
+
+ ok = application:unset_env(lager, log_root),
+ ?assertEqual(filename:absname("/foo/bar"), expand_path("/foo/bar")),
+ ?assertEqual(filename:absname("foo/bar"), expand_path("foo/bar")),
+
+ ok = application:set_env(lager, log_root, "log/dir"),
+ ?assertEqual(filename:absname("/foo/bar"), expand_path("/foo/bar")), % Absolute path should not be changed
+ ?assertEqual(filename:absname("log/dir/foo/bar"), expand_path("foo/bar")),
+
+ case OldRootVal of
+ undefined -> application:unset_env(lager, log_root);
+ {ok, Root} -> application:set_env(lager, log_root, Root)
+ end,
+ ok.
+
+sink_name_test_() ->
+ [
+ ?_assertEqual(lager_event, make_internal_sink_name(lager)),
+ ?_assertEqual(audit_lager_event, make_internal_sink_name(audit))
+ ].
+
+create_test_dir() ->
+ {ok, Tmp} = get_temp_dir(),
+ Dir = filename:join([Tmp, "lager_test",
+ erlang:integer_to_list(erlang:phash2(os:timestamp()))]),
+ ?assertEqual(ok, filelib:ensure_dir(Dir)),
+ TestDir = case file:make_dir(Dir) of
+ ok ->
+ Dir;
+ Err ->
+ ?assertEqual({error, eexist}, Err),
+ create_test_dir()
+ end,
+ ok = application:set_env(lager, test_dir, TestDir),
+ {ok, TestDir}.
+
+get_test_dir() ->
+ case application:get_env(lager, test_dir) of
+ undefined ->
+ create_test_dir();
+ {ok, _}=Res ->
+ Res
+ end.
+
+get_temp_dir() ->
+ Tmp = case os:getenv("TEMP") of
+ false ->
+ case os:getenv("TMP") of
+ false -> "/tmp";
+ Dir1 -> Dir1
+ end;
+ Dir0 -> Dir0
+ end,
+ ?assertEqual(true, filelib:is_dir(Tmp)),
+ {ok, Tmp}.
+
+delete_test_dir() ->
+ {ok, TestDir} = get_test_dir(),
+ ok = delete_test_dir(TestDir).
+
+delete_test_dir(TestDir) ->
+ ok = application:unset_env(lager, test_dir),
+ {OsType, _} = os:type(),
+ ok = case {OsType, otp_version()} of
+ {win32, _} ->
+ application:stop(lager),
+ do_delete_test_dir(TestDir);
+ {unix, 15} ->
+ os:cmd("rm -rf " ++ TestDir);
+ {unix, _} ->
+ do_delete_test_dir(TestDir)
+ end.
+
+do_delete_test_dir(Dir) ->
+ ListRet = file:list_dir_all(Dir),
+ ?assertMatch({ok, _}, ListRet),
+ {_, Entries} = ListRet,
+ lists:foreach(
+ fun(Entry) ->
+ FsElem = filename:join(Dir, Entry),
+ case filelib:is_dir(FsElem) of
+ true ->
+ delete_test_dir(FsElem);
+ _ ->
+ case file:delete(FsElem) of
+ ok -> ok;
+ Error ->
+ io:format(standard_error, "[ERROR]: error deleting file ~p~n", [FsElem]),
+ ?assertEqual(ok, Error)
+ end
+ end
+ end, Entries),
+ ?assertEqual(ok, file:del_dir(Dir)).
+
+do_delete_file(_FsElem, 0) ->
+ ?assert(false);
+do_delete_file(FsElem, Attempts) ->
+ case file:delete(FsElem) of
+ ok -> ok;
+ _Error ->
+ do_delete_file(FsElem, Attempts - 1)
+ end.
+
+set_dir_permissions(Perms, Dir) ->
+ do_set_dir_permissions(os:type(), Perms, Dir).
+
+do_set_dir_permissions({win32, _}, _Perms, _Dir) ->
+ ok;
+do_set_dir_permissions({unix, _}, Perms, Dir) ->
+ os:cmd("chmod -R " ++ Perms ++ " " ++ Dir),
+ ok.
+
+safe_application_load(App) ->
+ case application:load(App) of
+ ok ->
+ ok;
+ {error, {already_loaded, App}} ->
+ ok;
+ Error ->
+ ?assertEqual(ok, Error)
+ end.
+
+safe_write_file(File, Content) ->
+ % Note: ensures that the new creation time is at least one second
+ % in the future
+ ?assertEqual(ok, file:write_file(File, Content)),
+ Ctime0 = calendar:local_time(),
+ Ctime0Sec = calendar:datetime_to_gregorian_seconds(Ctime0),
+ Ctime1Sec = Ctime0Sec + 1,
+ Ctime1 = calendar:gregorian_seconds_to_datetime(Ctime1Sec),
+ {ok, FInfo0} = file:read_file_info(File, [raw]),
+ FInfo1 = FInfo0#file_info{ctime = Ctime1},
+ ?assertEqual(ok, file:write_file_info(File, FInfo1, [raw])).
+
+-endif.

guam-0.9.11.tar.gz/_checkouts/lager_syslog Added

guam-0.9.11.tar.gz/_checkouts/lager_syslog/.git Added

guam-0.9.11.tar.gz/_checkouts/lager_syslog/.git/HEAD Added

guam-0.9.11.tar.gz/_checkouts/lager_syslog/.git/branches Added

guam-0.9.11.tar.gz/_checkouts/lager_syslog/.git/config Added

guam-0.9.11.tar.gz/_checkouts/lager_syslog/.git/description Added

guam-0.9.11.tar.gz/_checkouts/lager_syslog/.git/hooks Added

guam-0.9.11.tar.gz/_checkouts/lager_syslog/.git/hooks/applypatch-msg.sample Added

guam-0.9.11.tar.gz/_checkouts/lager_syslog/.git/hooks/commit-msg.sample Added

guam-0.9.11.tar.gz/_checkouts/lager_syslog/.git/hooks/fsmonitor-watchman.sample Added

@@ -0,0 +1,173 @@
+#!/usr/bin/perl
+
+use strict;
+use warnings;
+use IPC::Open2;
+
+# An example hook script to integrate Watchman
+# (https://facebook.github.io/watchman/) with git to speed up detecting
+# new and modified files.
+#
+# The hook is passed a version (currently 2) and last update token
+# formatted as a string and outputs to stdout a new update token and
+# all files that have been modified since the update token. Paths must
+# be relative to the root of the working tree and separated by a single NUL.
+#
+# To enable this hook, rename this file to "query-watchman" and set
+# 'git config core.fsmonitor .git/hooks/query-watchman'
+#
+my ($version, $last_update_token) = @ARGV;
+
+# Uncomment for debugging
+# print STDERR "$0 $version $last_update_token\n";
+
+# Check the hook interface version
+if ($version ne 2) {
+	die "Unsupported query-fsmonitor hook version '$version'.\n" .
+	 "Falling back to scanning...\n";
+}
+
+my $git_work_tree = get_working_dir();
+
+my $retry = 1;
+
+my $json_pkg;
+eval {
+	require JSON::XS;
+	$json_pkg = "JSON::XS";
+	1;
+} or do {
+	require JSON::PP;
+	$json_pkg = "JSON::PP";
+};
+
+launch_watchman();
+
+sub launch_watchman {
+	my $o = watchman_query();
+	if (is_work_tree_watched($o)) {
+		output_result($o->{clock}, @{$o->{files}});
+	}
+}
+
+sub output_result {
+	my ($clockid, @files) = @_;
+
+	# Uncomment for debugging watchman output
+	# open (my $fh, ">", ".git/watchman-output.out");
+	# binmode $fh, ":utf8";
+	# print $fh "$clockid\n@files\n";
+	# close $fh;
+
+	binmode STDOUT, ":utf8";
+	print $clockid;
+	print "\0";
+	local $, = "\0";
+	print @files;
+}
+
+sub watchman_clock {
+	my $response = qx/watchman clock "$git_work_tree"/;
+	die "Failed to get clock id on '$git_work_tree'.\n" .
+		"Falling back to scanning...\n" if $? != 0;
+
+	return $json_pkg->new->utf8->decode($response);
+}
+
+sub watchman_query {
+	my $pid = open2(\*CHLD_OUT, \*CHLD_IN, 'watchman -j --no-pretty')
+	or die "open2() failed: $!\n" .
+	"Falling back to scanning...\n";
+
+	# In the query expression below we're asking for names of files that
+	# changed since $last_update_token but not from the .git folder.
+	#
+	# To accomplish this, we're using the "since" generator to use the
+	# recency index to select candidate nodes and "fields" to limit the
+	# output to file names only. Then we're using the "expression" term to
+	# further constrain the results.
+	if (substr($last_update_token, 0, 1) eq "c") {
+		$last_update_token = "\"$last_update_token\"";
+	}
+	my $query = <<"	END";
+		["query", "$git_work_tree", {
+			"since": $last_update_token,
+			"fields": ["name"],
+			"expression": ["not", ["dirname", ".git"]]
+		}]
+	END
+
+	# Uncomment for debugging the watchman query
+	# open (my $fh, ">", ".git/watchman-query.json");
+	# print $fh $query;
+	# close $fh;
+
+	print CHLD_IN $query;
+	close CHLD_IN;
+	my $response = do {local $/; <CHLD_OUT>};
+
+	# Uncomment for debugging the watch response
+	# open ($fh, ">", ".git/watchman-response.json");
+	# print $fh $response;
+	# close $fh;
+
+	die "Watchman: command returned no output.\n" .
+	"Falling back to scanning...\n" if $response eq "";
+	die "Watchman: command returned invalid output: $response\n" .
+	"Falling back to scanning...\n" unless $response =~ /^\{/;
+
+	return $json_pkg->new->utf8->decode($response);
+}
+
+sub is_work_tree_watched {
+	my ($output) = @_;
+	my $error = $output->{error};
+	if ($retry > 0 and $error and $error =~ m/unable to resolve root .* directory (.*) is not watched/) {
+		$retry--;
+		my $response = qx/watchman watch "$git_work_tree"/;
+		die "Failed to make watchman watch '$git_work_tree'.\n" .
+		 "Falling back to scanning...\n" if $? != 0;
+		$output = $json_pkg->new->utf8->decode($response);
+		$error = $output->{error};
+		die "Watchman: $error.\n" .
+		"Falling back to scanning...\n" if $error;
+
+		# Uncomment for debugging watchman output
+		# open (my $fh, ">", ".git/watchman-output.out");
+		# close $fh;
+
+		# Watchman will always return all files on the first query so
+		# return the fast "everything is dirty" flag to git and do the
+		# Watchman query just to get it over with now so we won't pay
+		# the cost in git to look up each individual file.
+		my $o = watchman_clock();
+		$error = $output->{error};
+
+		die "Watchman: $error.\n" .
+		"Falling back to scanning...\n" if $error;
+
+		output_result($o->{clock}, ("/"));
+		$last_update_token = $o->{clock};
+
+		eval { launch_watchman() };
+		return 0;
+	}
+
+	die "Watchman: $error.\n" .
+	"Falling back to scanning...\n" if $error;
+
+	return 1;
+}
+
+sub get_working_dir {
+	my $working_dir;
+	if ($^O =~ 'msys' || $^O =~ 'cygwin') {
+		$working_dir = Win32::GetCwd();
+		$working_dir =~ tr/\\/\//;
+	} else {
+		require Cwd;
+		$working_dir = Cwd::cwd();
+	}
+
+	return $working_dir;
+}

guam-0.9.11.tar.gz/_checkouts/lager_syslog/.git/hooks/post-update.sample Added

guam-0.9.11.tar.gz/_checkouts/lager_syslog/.git/hooks/pre-applypatch.sample Added

guam-0.9.11.tar.gz/_checkouts/lager_syslog/.git/hooks/pre-commit.sample Added

@@ -0,0 +1,49 @@
+#!/usr/bin/sh
+#
+# An example 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.
+#
+# To enable this hook, rename this file to "pre-commit".
+
+if git rev-parse --verify HEAD >/dev/null 2>&1
+then
+	against=HEAD
+else
+	# Initial commit: diff against an empty tree object
+	against=$(git hash-object -t tree /dev/null)
+fi
+
+# If you want to allow non-ASCII filenames set this variable to true.
+allownonascii=$(git config --type=bool hooks.allownonascii)
+
+# Redirect output to stderr.
+exec 1>&2
+
+# Cross platform projects tend to avoid non-ASCII filenames; prevent
+# them from being added to the repository. We exploit the fact that the
+# printable range starts at the space character and ends with tilde.
+if [ "$allownonascii" != "true" ] &&
+	# 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.
+	test $(git diff --cached --name-only --diff-filter=A -z $against |
+	 LC_ALL=C tr -d '[ -~]\0' | wc -c) != 0
+then
+	cat <<\EOF
+Error: Attempt to add a non-ASCII file name.
+
+This can cause problems if you want to work with people on other platforms.
+
+To be portable it is advisable to rename the file.
+
+If you know what you are doing you can disable this check using:
+
+ git config hooks.allownonascii true
+EOF
+	exit 1
+fi
+
+# If there are whitespace errors, print the offending file names and fail.
+exec git diff-index --check --cached $against --

guam-0.9.11.tar.gz/_checkouts/lager_syslog/.git/hooks/pre-merge-commit.sample Added

guam-0.9.11.tar.gz/_checkouts/lager_syslog/.git/hooks/pre-push.sample Added

@@ -0,0 +1,53 @@
+#!/usr/bin/sh
+
+# An example hook script to verify what is about to be pushed. Called by "git
+# push" after it has checked the remote status, but before anything has been
+# pushed. If this script exits with a non-zero status nothing will be pushed.
+#
+# This hook is called with the following parameters:
+#
+# $1 -- Name of the remote to which the push is being done
+# $2 -- URL to which the push is being done
+#
+# If pushing without using a named remote those arguments will be equal.
+#
+# Information about the commits which are being pushed is supplied as lines to
+# the standard input in the form:
+#
+# <local ref> <local oid> <remote ref> <remote oid>
+#
+# This sample shows how to prevent push of commits where the log message starts
+# with "WIP" (work in progress).
+
+remote="$1"
+url="$2"
+
+zero=$(git hash-object --stdin </dev/null | tr '[0-9a-f]' '0')
+
+while read local_ref local_oid remote_ref remote_oid
+do
+	if test "$local_oid" = "$zero"
+	then
+		# Handle delete
+		:
+	else
+		if test "$remote_oid" = "$zero"
+		then
+			# New branch, examine all commits
+			range="$local_oid"
+		else
+			# Update to existing branch, examine new commits
+			range="$remote_oid..$local_oid"
+		fi
+
+		# Check for WIP commit
+		commit=$(git rev-list -n 1 --grep '^WIP' "$range")
+		if test -n "$commit"
+		then
+			echo >&2 "Found WIP commit in $local_ref, not pushing"
+			exit 1
+		fi
+	fi
+done
+
+exit 0

guam-0.9.11.tar.gz/_checkouts/lager_syslog/.git/hooks/pre-rebase.sample Added

@@ -0,0 +1,169 @@
+#!/usr/bin/sh
+#
+# Copyright (c) 2006, 2008 Junio C Hamano
+#
+# The "pre-rebase" hook is run just before "git rebase" starts doing
+# its job, and can prevent the command from running by exiting with
+# non-zero status.
+#
+# The hook is called with the following parameters:
+#
+# $1 -- the upstream the series was forked from.
+# $2 -- the branch being rebased (or empty when rebasing the current branch).
+#
+# This sample shows how to prevent topic branches that are already
+# merged to 'next' branch from getting rebased, because allowing it
+# would result in rebasing already published history.
+
+publish=next
+basebranch="$1"
+if test "$#" = 2
+then
+	topic="refs/heads/$2"
+else
+	topic=`git symbolic-ref HEAD` ||
+	exit 0 ;# we do not interrupt rebasing detached HEAD
+fi
+
+case "$topic" in
+refs/heads/??/*)
+	;;
+*)
+	exit 0 ;# we do not interrupt others.
+	;;
+esac
+
+# Now we are dealing with a topic branch being rebased
+# on top of master. Is it OK to rebase it?
+
+# Does the topic really exist?
+git show-ref -q "$topic" || {
+	echo >&2 "No such branch $topic"
+	exit 1
+}
+
+# Is topic fully merged to master?
+not_in_master=`git rev-list --pretty=oneline ^master "$topic"`
+if test -z "$not_in_master"
+then
+	echo >&2 "$topic is fully merged to master; better remove it."
+	exit 1 ;# we could allow it, but there is no point.
+fi
+
+# Is topic ever merged to next? If so you should not be rebasing it.
+only_next_1=`git rev-list ^master "^$topic" ${publish} | sort`
+only_next_2=`git rev-list ^master ${publish} | sort`
+if test "$only_next_1" = "$only_next_2"
+then
+	not_in_topic=`git rev-list "^$topic" master`
+	if test -z "$not_in_topic"
+	then
+		echo >&2 "$topic is already up to date with master"
+		exit 1 ;# we could allow it, but there is no point.
+	else
+		exit 0
+	fi
+else
+	not_in_next=`git rev-list --pretty=oneline ^${publish} "$topic"`
+	/usr/bin/perl -e '
+		my $topic = $ARGV[0];
+		my $msg = "* $topic has commits already merged to public branch:\n";
+		my (%not_in_next) = map {
+			/^([0-9a-f]+) /;
+			($1 => 1);
+		} split(/\n/, $ARGV[1]);
+		for my $elem (map {
+				/^([0-9a-f]+) (.*)$/;
+				[$1 => $2];
+			} split(/\n/, $ARGV[2])) {
+			if (!exists $not_in_next{$elem->[0]}) {
+				if ($msg) {
+					print STDERR $msg;
+					undef $msg;
+				}
+				print STDERR " $elem->[1]\n";
+			}
+		}
+	' "$topic" "$not_in_next" "$not_in_master"
+	exit 1
+fi
+
+<<\DOC_END
+
+This sample hook safeguards topic branches that have been
+published from being rewound.
+
+The workflow assumed here is:
+
+ * Once a topic branch forks from "master", "master" is never
+ merged into it again (either directly or indirectly).
+
+ * Once a topic branch is fully cooked and merged into "master",
+ it is deleted. If you need to build on top of it to correct
+ earlier mistakes, a new topic branch is created by forking at
+ the tip of the "master". This is not strictly necessary, but
+ it makes it easier to keep your history simple.
+
+ * Whenever you need to test or publish your changes to topic
+ branches, merge them into "next" branch.
+
+The script, being an example, hardcodes the publish branch name
+to be "next", but it is trivial to make it configurable via
+$GIT_DIR/config mechanism.
+
+With this workflow, you would want to know:
+
+(1) ... if a topic branch has ever been merged to "next". Young
+ topic branches can have stupid mistakes you would rather
+ clean up before publishing, and things that have not been
+ merged into other branches can be easily rebased without
+ affecting other people. But once it is published, you would
+ not want to rewind it.
+
+(2) ... if a topic branch has been fully merged to "master".
+ Then you can delete it. More importantly, you should not
+ build on top of it -- other people may already want to
+ change things related to the topic as patches against your
+ "master", so if you need further changes, it is better to
+ fork the topic (perhaps with the same name) afresh from the
+ tip of "master".
+
+Let's look at this example:
+
+		 o---o---o---o---o---o---o---o---o---o "next"
+		 / / / /
+		 / a---a---b A / /
+		/ / / /
+	 / / c---c---c---c B /
+	 / / / \ /
+	 / / / b---b C \ /
+	 / / / / \ /
+ ---o---o---o---o---o---o---o---o---o---o---o "master"
+
+
+A, B and C are topic branches.
+
+ * A has one fix since it was merged up to "next".
+
+ * B has finished. It has been fully merged up to "master" and "next",
+ and is ready to be deleted.
+
+ * C has not merged to "next" at all.
+
+We would want to allow C to be rebased, refuse A, and encourage
+B to be deleted.
+
+To compute (1):
+
+	git rev-list ^master ^topic next
+	git rev-list ^master next
+
+	if these match, topic has not merged in next at all.
+
+To compute (2):
+
+	git rev-list master..topic
+
+	if this is empty, it is fully merged to "master".
+
+DOC_END

guam-0.9.11.tar.gz/_checkouts/lager_syslog/.git/hooks/pre-receive.sample Added

guam-0.9.11.tar.gz/_checkouts/lager_syslog/.git/hooks/prepare-commit-msg.sample Added

@@ -0,0 +1,42 @@
+#!/usr/bin/sh
+#
+# An example hook script to prepare the commit log message.
+# Called by "git commit" with the name of the file that has the
+# commit message, followed by the description of the commit
+# message's source.  The hook's purpose is to edit the commit
+# message file.  If the hook fails with a non-zero status,
+# the commit is aborted.
+#
+# To enable this hook, rename this file to "prepare-commit-msg".
+
+# This hook includes three examples. The first one removes the
+# "# Please enter the commit message..." help message.
+#
+# The second includes the output of "git diff --name-status -r"
+# into the message, just before the "git status" output.  It is
+# commented because it doesn't cope with --amend or with squashed
+# commits.
+#
+# The third example adds a Signed-off-by line to the message, that can
+# still be edited.  This is rarely a good idea.
+
+COMMIT_MSG_FILE=$1
+COMMIT_SOURCE=$2
+SHA1=$3
+
+/usr/bin/perl -i.bak -ne 'print unless(m/^. Please enter the commit message/..m/^#$/)' "$COMMIT_MSG_FILE"
+
+# case "$COMMIT_SOURCE,$SHA1" in
+#  ,|template,)
+#    /usr/bin/perl -i.bak -pe '
+#       print "\n" . `git diff --cached --name-status -r`
+# 	 if /^#/ && $first++ == 0' "$COMMIT_MSG_FILE" ;;
+#  *) ;;
+# esac
+
+# SOB=$(git var GIT_COMMITTER_IDENT | sed -n 's/^$.*>$.*$/Signed-off-by: \1/p')
+# git interpret-trailers --in-place --trailer "$SOB" "$COMMIT_MSG_FILE"
+# if test -z "$COMMIT_SOURCE"
+# then
+#   /usr/bin/perl -i.bak -pe 'print "\n" if !$first_line++' "$COMMIT_MSG_FILE"
+# fi

guam-0.9.11.tar.gz/_checkouts/lager_syslog/.git/hooks/push-to-checkout.sample Added

@@ -0,0 +1,78 @@
+#!/usr/bin/sh
+
+# An example hook script to update a checked-out tree on a git push.
+#
+# This hook is invoked by git-receive-pack(1) when it reacts to git
+# push and updates reference(s) in its repository, and when the push
+# tries to update the branch that is currently checked out and the
+# receive.denyCurrentBranch configuration variable is set to
+# updateInstead.
+#
+# By default, such a push is refused if the working tree and the index
+# of the remote repository has any difference from the currently
+# checked out commit; when both the working tree and the index match
+# the current commit, they are updated to match the newly pushed tip
+# of the branch. This hook is to be used to override the default
+# behaviour; however the code below reimplements the default behaviour
+# as a starting point for convenient modification.
+#
+# The hook receives the commit with which the tip of the current
+# branch is going to be updated:
+commit=$1
+
+# It can exit with a non-zero status to refuse the push (when it does
+# so, it must not modify the index or the working tree).
+die () {
+	echo >&2 "$*"
+	exit 1
+}
+
+# Or it can make any necessary changes to the working tree and to the
+# index to bring them to the desired state when the tip of the current
+# branch is updated to the new commit, and exit with a zero status.
+#
+# For example, the hook can simply run git read-tree -u -m HEAD "$1"
+# in order to emulate git fetch that is run in the reverse direction
+# with git push, as the two-tree form of git read-tree -u -m is
+# essentially the same as git switch or git checkout that switches
+# branches while keeping the local changes in the working tree that do
+# not interfere with the difference between the branches.
+
+# The below is a more-or-less exact translation to shell of the C code
+# for the default behaviour for git's push-to-checkout hook defined in
+# the push_to_deploy() function in builtin/receive-pack.c.
+#
+# Note that the hook will be executed from the repository directory,
+# not from the working tree, so if you want to perform operations on
+# the working tree, you will have to adapt your code accordingly, e.g.
+# by adding "cd .." or using relative paths.
+
+if ! git update-index -q --ignore-submodules --refresh
+then
+	die "Up-to-date check failed"
+fi
+
+if ! git diff-files --quiet --ignore-submodules --
+then
+	die "Working directory has unstaged changes"
+fi
+
+# This is a rough translation of:
+#
+# head_has_history() ? "HEAD" : EMPTY_TREE_SHA1_HEX
+if git cat-file -e HEAD 2>/dev/null
+then
+	head=HEAD
+else
+	head=$(git hash-object -t tree --stdin </dev/null)
+fi
+
+if ! git diff-index --quiet --cached --ignore-submodules $head --
+then
+	die "Working directory has staged changes"
+fi
+
+if ! git read-tree -u -m "$commit"
+then
+	die "Could not update working tree to new HEAD"
+fi

guam-0.9.11.tar.gz/_checkouts/lager_syslog/.git/hooks/update.sample Added

@@ -0,0 +1,128 @@
+#!/usr/bin/sh
+#
+# An example hook script to block unannotated tags from entering.
+# Called by "git receive-pack" with arguments: refname sha1-old sha1-new
+#
+# To enable this hook, rename this file to "update".
+#
+# Config
+# ------
+# hooks.allowunannotated
+# This boolean sets whether unannotated tags will be allowed into the
+# repository. By default they won't be.
+# hooks.allowdeletetag
+# This boolean sets whether deleting tags will be allowed in the
+# repository. By default they won't be.
+# hooks.allowmodifytag
+# This boolean sets whether a tag may be modified after creation. By default
+# it won't be.
+# hooks.allowdeletebranch
+# This boolean sets whether deleting branches will be allowed in the
+# repository. By default they won't be.
+# hooks.denycreatebranch
+# This boolean sets whether remotely creating branches will be denied
+# in the repository. By default this is allowed.
+#
+
+# --- Command line
+refname="$1"
+oldrev="$2"
+newrev="$3"
+
+# --- Safety check
+if [ -z "$GIT_DIR" ]; then
+	echo "Don't run this script from the command line." >&2
+	echo " (if you want, you could supply GIT_DIR then run" >&2
+	echo " $0 <ref> <oldrev> <newrev>)" >&2
+	exit 1
+fi
+
+if [ -z "$refname" -o -z "$oldrev" -o -z "$newrev" ]; then
+	echo "usage: $0 <ref> <oldrev> <newrev>" >&2
+	exit 1
+fi
+
+# --- Config
+allowunannotated=$(git config --type=bool hooks.allowunannotated)
+allowdeletebranch=$(git config --type=bool hooks.allowdeletebranch)
+denycreatebranch=$(git config --type=bool hooks.denycreatebranch)
+allowdeletetag=$(git config --type=bool hooks.allowdeletetag)
+allowmodifytag=$(git config --type=bool hooks.allowmodifytag)
+
+# check for no description
+projectdesc=$(sed -e '1q' "$GIT_DIR/description")
+case "$projectdesc" in
+"Unnamed repository"* | "")
+	echo "*** Project description file hasn't been set" >&2
+	exit 1
+	;;
+esac
+
+# --- Check types
+# if $newrev is 0000...0000, it's a commit to delete a ref.
+zero=$(git hash-object --stdin </dev/null | tr '[0-9a-f]' '0')
+if [ "$newrev" = "$zero" ]; then
+	newrev_type=delete
+else
+	newrev_type=$(git cat-file -t $newrev)
+fi
+
+case "$refname","$newrev_type" in
+	refs/tags/*,commit)
+		# un-annotated tag
+		short_refname=${refname##refs/tags/}
+		if [ "$allowunannotated" != "true" ]; then
+			echo "*** The un-annotated tag, $short_refname, is not allowed in this repository" >&2
+			echo "*** Use 'git tag [ -a | -s ]' for tags you want to propagate." >&2
+			exit 1
+		fi
+		;;
+	refs/tags/*,delete)
+		# delete tag
+		if [ "$allowdeletetag" != "true" ]; then
+			echo "*** Deleting a tag is not allowed in this repository" >&2
+			exit 1
+		fi
+		;;
+	refs/tags/*,tag)
+		# annotated tag
+		if [ "$allowmodifytag" != "true" ] && git rev-parse $refname > /dev/null 2>&1
+		then
+			echo "*** Tag '$refname' already exists." >&2
+			echo "*** Modifying a tag is not allowed in this repository." >&2
+			exit 1
+		fi
+		;;
+	refs/heads/*,commit)
+		# branch
+		if [ "$oldrev" = "$zero" -a "$denycreatebranch" = "true" ]; then
+			echo "*** Creating a branch is not allowed in this repository" >&2
+			exit 1
+		fi
+		;;
+	refs/heads/*,delete)
+		# delete branch
+		if [ "$allowdeletebranch" != "true" ]; then
+			echo "*** Deleting a branch is not allowed in this repository" >&2
+			exit 1
+		fi
+		;;
+	refs/remotes/*,commit)
+		# tracking branch
+		;;
+	refs/remotes/*,delete)
+		# delete tracking branch
+		if [ "$allowdeletebranch" != "true" ]; then
+			echo "*** Deleting a tracking branch is not allowed in this repository" >&2
+			exit 1
+		fi
+		;;
+	*)
+		# Anything else (is there anything else?)
+		echo "*** Update hook: unknown type of update to ref $refname of type $newrev_type" >&2
+		exit 1
+		;;
+esac
+
+# --- Finished
+exit 0

guam-0.9.11.tar.gz/_checkouts/lager_syslog/.git/index Added

guam-0.9.11.tar.gz/_checkouts/lager_syslog/.git/info Added

guam-0.9.11.tar.gz/_checkouts/lager_syslog/.git/info/exclude Added

guam-0.9.11.tar.gz/_checkouts/lager_syslog/.git/logs Added

guam-0.9.11.tar.gz/_checkouts/lager_syslog/.git/logs/HEAD Added

guam-0.9.11.tar.gz/_checkouts/lager_syslog/.git/objects Added

guam-0.9.11.tar.gz/_checkouts/lager_syslog/.git/objects/info Added

guam-0.9.11.tar.gz/_checkouts/lager_syslog/.git/objects/pack Added

guam-0.9.11.tar.gz/_checkouts/lager_syslog/.git/objects/pack/pack-fd92f774b6c37e398e2e1178b7a16ee6a239a885.idx Added

guam-0.9.11.tar.gz/_checkouts/lager_syslog/.git/objects/pack/pack-fd92f774b6c37e398e2e1178b7a16ee6a239a885.pack Added

guam-0.9.11.tar.gz/_checkouts/lager_syslog/.git/packed-refs Added

guam-0.9.11.tar.gz/_checkouts/lager_syslog/.git/refs Added

guam-0.9.11.tar.gz/_checkouts/lager_syslog/.git/refs/heads Added

guam-0.9.11.tar.gz/_checkouts/lager_syslog/.git/refs/tags Added

guam-0.9.11.tar.gz/_checkouts/lager_syslog/.git/refs/tags/1.2.1 Added

guam-0.9.11.tar.gz/_checkouts/lager_syslog/.gitignore Added

guam-0.9.11.tar.gz/_checkouts/lager_syslog/.travis.yml Added

guam-0.9.11.tar.gz/_checkouts/lager_syslog/LICENSE Added

@@ -0,0 +1,178 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+

guam-0.9.11.tar.gz/_checkouts/lager_syslog/Makefile Added

@@ -0,0 +1,52 @@
+.PHONY: rel stagedevrel deps test
+
+all: deps compile
+
+compile:
+	./rebar compile
+
+deps:
+	./rebar get-deps
+
+clean:
+	./rebar clean
+
+distclean: clean
+	./rebar delete-deps
+
+test:
+	./rebar eunit
+
+##
+## Doc targets
+##
+docs:
+	./rebar doc
+
+APPS = kernel stdlib sasl erts ssl tools os_mon runtime_tools crypto inets \
+	xmerl webtool snmp public_key mnesia eunit syntax_tools compiler
+COMBO_PLT = $(HOME)/.riak_combo_dialyzer_plt
+
+check_plt: compile
+	dialyzer --check_plt --plt $(COMBO_PLT) --apps $(APPS)
+
+build_plt: compile
+	dialyzer --build_plt --output_plt $(COMBO_PLT) --apps $(APPS)
+
+dialyzer: compile
+	@echo
+	@echo Use "'make check_plt'" to check PLT prior to using this target.
+	@echo Use "'make build_plt'" to build PLT prior to using this target.
+	@echo
+	@sleep 1
+	dialyzer -Wno_return --plt $(COMBO_PLT) ebin | \
+	    fgrep -v -f ./dialyzer.ignore-warnings
+
+cleanplt:
+	@echo 
+	@echo "Are you sure?  It takes about 1/2 hour to re-build."
+	@echo Deleting $(COMBO_PLT) in 5 seconds.
+	@echo 
+	sleep 5
+	rm $(COMBO_PLT)
+

guam-0.9.11.tar.gz/_checkouts/lager_syslog/README.org Added

@@ -0,0 +1,53 @@
+* Overview
+  [[http://travis-ci.org/basho/lager_syslog][Travis-CI]] :: [[https://secure.travis-ci.org/basho/lager_syslog.png]]
+
+  This is a syslog backend for [[https://github.com/basho/lager][Lager]]. It
+  allows you to send messages out of lager and into the local syslog daemon.
+
+* Configuration
+  Configure a Lager handler like the following:
+
+#+BEGIN_EXAMPLE
+  {lager_syslog_backend, [Identity, Facility, Level]}
+#+END_EXAMPLE
+
+  The Identity is the string to tag all messages with in syslog, usually the
+  application's name. The facility is the facility to log to (see the syslog
+  documentation for a list of these). The Level is the lager level at which the
+  backend accepts messages (eg. using 'info' would send all messages at info
+  level or above into syslog). While you can filter messages at the syslog
+  level, it will improve performance if you filter in lager instead.
+
+  An example for [[http://www.basho.com/products_riak_overview.php][riak]]
+  would look something like this:
+
+#+BEGIN_EXAMPLE
+  {handlers, [
+    {lager_syslog_backend, ["riak", local1, info]},
+  ] },
+#+END_EXAMPLE
+
+  Then in your syslog config remembering syslog likes tabs and not spaces:
+
+#+BEGIN_EXAMPLE
+  local1.info                     /var/log/riak_info.log
+#+END_EXAMPLE
+
+  If you want to log to multiple facilities at once, you can do something like
+  the following:
+
+#+BEGIN_EXAMPLE
+  {{lager_syslog_backend, "daemon facility"}, ["riak1", daemon, info]},
+  {{lager_syslog_backend, ftp}, ["riak2", ftp, notice]},
+#+END_EXAMPLE
+
+  You MUST give each instance of the file backend its own identifier.
+
+  Refer to Lager's documentation for futher information on configuring handlers.
+
+* Troubleshooting
+  There's not a lot to go wrong, but if you are not receiving messages, check
+  your syslog config and read its manpage for more information. OS X, in
+  particular, has a very strange default config where it drops messages below
+  the 'info' level by default.
+

guam-0.9.11.tar.gz/_checkouts/lager_syslog/rebar Added

guam-0.9.11.tar.gz/_checkouts/lager_syslog/rebar.config Added

guam-0.9.11.tar.gz/_checkouts/lager_syslog/src Added

guam-0.9.11.tar.gz/_checkouts/lager_syslog/src/lager_syslog.app.src Added

guam-0.9.11.tar.gz/_checkouts/lager_syslog/src/lager_syslog_backend.erl Added

@@ -0,0 +1,141 @@
+%% Copyright (c) 2011-2012 Basho Technologies, Inc. All Rights Reserved.
+%%
+%% This file is provided to you 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.
+
+%% @doc Syslog backend for lager.
+
+-module(lager_syslog_backend).
+
+-behaviour(gen_event).
+
+-export([init/1, handle_call/2, handle_event/2, handle_info/2, terminate/2,
+ code_change/3]).
+
+-export([config_to_id/1]).
+
+-record(state, {level, handle, id, formatter,format_config}).
+
+-include_lib("lager/include/lager.hrl").
+
+-define(DEFAULT_FORMAT,["[", severity, "] ",
+ {pid, ""},
+ {module, [
+ {pid, ["@"], ""},
+ module,
+ {function, [":", function], ""},
+ {line, [":",line], ""}], ""},
+ " ", message]).
+
+
+%% @private
+init([Ident, Facility, Level]) ->
+ init([Ident, Facility, Level, {lager_default_formatter, ?DEFAULT_FORMAT}]);
+init([Ident, Facility, Level, {Formatter, FormatterConfig}]) when is_atom(Formatter) ->
+ case application:start(syslog) of
+ ok ->
+ init2([Ident, Facility, Level, {Formatter, FormatterConfig}]);
+ {error, {already_started, _}} ->
+ init2([Ident, Facility, Level, {Formatter, FormatterConfig}]);
+ Error ->
+ Error
+ end.
+
+%% @private
+init2([Ident, Facility, Level, {Formatter, FormatterConfig}]) ->
+ case syslog:open(Ident, [pid], Facility) of
+ {ok, Log} ->
+ try parse_level(Level) of
+ Lvl ->
+ {ok, #state{level=Lvl,
+ id=config_to_id([Ident, Facility, Level]),
+ handle=Log,
+ formatter=Formatter,
+ format_config=FormatterConfig}}
+ catch
+ _:_ ->
+ {error, bad_log_level}
+ end;
+ Error ->
+ Error
+ end.
+
+
+%% @private
+handle_call(get_loglevel, #state{level=Level} = State) ->
+ {ok, Level, State};
+handle_call({set_loglevel, Level}, State) ->
+ try parse_level(Level) of
+ Lvl ->
+ {ok, ok, State#state{level=Lvl}}
+ catch
+ _:_ ->
+ {ok, {error, bad_log_level}, State}
+ end;
+handle_call(_Request, State) ->
+ {ok, ok, State}.
+
+%% @private
+handle_event({log, Level, {_Date, _Time}, [_LevelStr, Location, Message]},
+ #state{level=LogLevel} = State) when Level =< LogLevel ->
+ syslog:log(State#state.handle, convert_level(Level), [Location, Message]),
+ {ok, State};
+handle_event({log, Message}, #state{level=Level,formatter=Formatter,format_config=FormatConfig} = State) ->
+ case lager_util:is_loggable(Message, Level, State#state.id) of
+ true ->
+ syslog:log(State#state.handle, convert_level(lager_msg:severity_as_int(Message)), [Formatter:format(Message, FormatConfig)]),
+ {ok, State};
+ false ->
+ {ok, State}
+ end;
+handle_event(_Event, State) ->
+ {ok, State}.
+
+%% @private
+handle_info(_Info, State) ->
+ {ok, State}.
+
+%% @private
+terminate(_Reason, _State) ->
+ ok.
+
+%% @private
+code_change(_OldVsn, State, _Extra) ->
+ {ok, State}.
+
+%% convert the configuration into a hopefully unique gen_event ID
+config_to_id([Ident, Facility, _Level]) ->
+ {?MODULE, {Ident, Facility}};
+config_to_id([Ident, Facility, _Level, _Formatter]) ->
+ {?MODULE, {Ident, Facility}}.
+
+convert_level(?DEBUG) -> debug;
+convert_level(?INFO) -> info;
+convert_level(?NOTICE) -> notice;
+convert_level(?WARNING) -> warning;
+convert_level(?ERROR) -> err;
+convert_level(?CRITICAL) -> crit;
+convert_level(?ALERT) -> alert;
+convert_level(?EMERGENCY) -> emerg.
+
+parse_level(Level) ->
+ try lager_util:config_to_mask(Level) of
+ Res ->
+ Res
+ catch
+ error:undef ->
+ %% must be lager < 2.0
+ lager_util:level_to_num(Level)
+ end.
+

guam-0.9.11.tar.gz/_checkouts/syslog Added

guam-0.9.11.tar.gz/_checkouts/syslog/.git Added

guam-0.9.11.tar.gz/_checkouts/syslog/.git/HEAD Added

guam-0.9.11.tar.gz/_checkouts/syslog/.git/branches Added

guam-0.9.11.tar.gz/_checkouts/syslog/.git/config Added

guam-0.9.11.tar.gz/_checkouts/syslog/.git/description Added

guam-0.9.11.tar.gz/_checkouts/syslog/.git/hooks Added

guam-0.9.11.tar.gz/_checkouts/syslog/.git/hooks/applypatch-msg.sample Added

guam-0.9.11.tar.gz/_checkouts/syslog/.git/hooks/commit-msg.sample Added

guam-0.9.11.tar.gz/_checkouts/syslog/.git/hooks/fsmonitor-watchman.sample Added

@@ -0,0 +1,173 @@
+#!/usr/bin/perl
+
+use strict;
+use warnings;
+use IPC::Open2;
+
+# An example hook script to integrate Watchman
+# (https://facebook.github.io/watchman/) with git to speed up detecting
+# new and modified files.
+#
+# The hook is passed a version (currently 2) and last update token
+# formatted as a string and outputs to stdout a new update token and
+# all files that have been modified since the update token. Paths must
+# be relative to the root of the working tree and separated by a single NUL.
+#
+# To enable this hook, rename this file to "query-watchman" and set
+# 'git config core.fsmonitor .git/hooks/query-watchman'
+#
+my ($version, $last_update_token) = @ARGV;
+
+# Uncomment for debugging
+# print STDERR "$0 $version $last_update_token\n";
+
+# Check the hook interface version
+if ($version ne 2) {
+	die "Unsupported query-fsmonitor hook version '$version'.\n" .
+	 "Falling back to scanning...\n";
+}
+
+my $git_work_tree = get_working_dir();
+
+my $retry = 1;
+
+my $json_pkg;
+eval {
+	require JSON::XS;
+	$json_pkg = "JSON::XS";
+	1;
+} or do {
+	require JSON::PP;
+	$json_pkg = "JSON::PP";
+};
+
+launch_watchman();
+
+sub launch_watchman {
+	my $o = watchman_query();
+	if (is_work_tree_watched($o)) {
+		output_result($o->{clock}, @{$o->{files}});
+	}
+}
+
+sub output_result {
+	my ($clockid, @files) = @_;
+
+	# Uncomment for debugging watchman output
+	# open (my $fh, ">", ".git/watchman-output.out");
+	# binmode $fh, ":utf8";
+	# print $fh "$clockid\n@files\n";
+	# close $fh;
+
+	binmode STDOUT, ":utf8";
+	print $clockid;
+	print "\0";
+	local $, = "\0";
+	print @files;
+}
+
+sub watchman_clock {
+	my $response = qx/watchman clock "$git_work_tree"/;
+	die "Failed to get clock id on '$git_work_tree'.\n" .
+		"Falling back to scanning...\n" if $? != 0;
+
+	return $json_pkg->new->utf8->decode($response);
+}
+
+sub watchman_query {
+	my $pid = open2(\*CHLD_OUT, \*CHLD_IN, 'watchman -j --no-pretty')
+	or die "open2() failed: $!\n" .
+	"Falling back to scanning...\n";
+
+	# In the query expression below we're asking for names of files that
+	# changed since $last_update_token but not from the .git folder.
+	#
+	# To accomplish this, we're using the "since" generator to use the
+	# recency index to select candidate nodes and "fields" to limit the
+	# output to file names only. Then we're using the "expression" term to
+	# further constrain the results.
+	if (substr($last_update_token, 0, 1) eq "c") {
+		$last_update_token = "\"$last_update_token\"";
+	}
+	my $query = <<"	END";
+		["query", "$git_work_tree", {
+			"since": $last_update_token,
+			"fields": ["name"],
+			"expression": ["not", ["dirname", ".git"]]
+		}]
+	END
+
+	# Uncomment for debugging the watchman query
+	# open (my $fh, ">", ".git/watchman-query.json");
+	# print $fh $query;
+	# close $fh;
+
+	print CHLD_IN $query;
+	close CHLD_IN;
+	my $response = do {local $/; <CHLD_OUT>};
+
+	# Uncomment for debugging the watch response
+	# open ($fh, ">", ".git/watchman-response.json");
+	# print $fh $response;
+	# close $fh;
+
+	die "Watchman: command returned no output.\n" .
+	"Falling back to scanning...\n" if $response eq "";
+	die "Watchman: command returned invalid output: $response\n" .
+	"Falling back to scanning...\n" unless $response =~ /^\{/;
+
+	return $json_pkg->new->utf8->decode($response);
+}
+
+sub is_work_tree_watched {
+	my ($output) = @_;
+	my $error = $output->{error};
+	if ($retry > 0 and $error and $error =~ m/unable to resolve root .* directory (.*) is not watched/) {
+		$retry--;
+		my $response = qx/watchman watch "$git_work_tree"/;
+		die "Failed to make watchman watch '$git_work_tree'.\n" .
+		 "Falling back to scanning...\n" if $? != 0;
+		$output = $json_pkg->new->utf8->decode($response);
+		$error = $output->{error};
+		die "Watchman: $error.\n" .
+		"Falling back to scanning...\n" if $error;
+
+		# Uncomment for debugging watchman output
+		# open (my $fh, ">", ".git/watchman-output.out");
+		# close $fh;
+
+		# Watchman will always return all files on the first query so
+		# return the fast "everything is dirty" flag to git and do the
+		# Watchman query just to get it over with now so we won't pay
+		# the cost in git to look up each individual file.
+		my $o = watchman_clock();
+		$error = $output->{error};
+
+		die "Watchman: $error.\n" .
+		"Falling back to scanning...\n" if $error;
+
+		output_result($o->{clock}, ("/"));
+		$last_update_token = $o->{clock};
+
+		eval { launch_watchman() };
+		return 0;
+	}
+
+	die "Watchman: $error.\n" .
+	"Falling back to scanning...\n" if $error;
+
+	return 1;
+}
+
+sub get_working_dir {
+	my $working_dir;
+	if ($^O =~ 'msys' || $^O =~ 'cygwin') {
+		$working_dir = Win32::GetCwd();
+		$working_dir =~ tr/\\/\//;
+	} else {
+		require Cwd;
+		$working_dir = Cwd::cwd();
+	}
+
+	return $working_dir;
+}

guam-0.9.11.tar.gz/_checkouts/syslog/.git/hooks/post-update.sample Added

guam-0.9.11.tar.gz/_checkouts/syslog/.git/hooks/pre-applypatch.sample Added

guam-0.9.11.tar.gz/_checkouts/syslog/.git/hooks/pre-commit.sample Added

@@ -0,0 +1,49 @@
+#!/usr/bin/sh
+#
+# An example 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.
+#
+# To enable this hook, rename this file to "pre-commit".
+
+if git rev-parse --verify HEAD >/dev/null 2>&1
+then
+	against=HEAD
+else
+	# Initial commit: diff against an empty tree object
+	against=$(git hash-object -t tree /dev/null)
+fi
+
+# If you want to allow non-ASCII filenames set this variable to true.
+allownonascii=$(git config --type=bool hooks.allownonascii)
+
+# Redirect output to stderr.
+exec 1>&2
+
+# Cross platform projects tend to avoid non-ASCII filenames; prevent
+# them from being added to the repository. We exploit the fact that the
+# printable range starts at the space character and ends with tilde.
+if [ "$allownonascii" != "true" ] &&
+	# 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.
+	test $(git diff --cached --name-only --diff-filter=A -z $against |
+	 LC_ALL=C tr -d '[ -~]\0' | wc -c) != 0
+then
+	cat <<\EOF
+Error: Attempt to add a non-ASCII file name.
+
+This can cause problems if you want to work with people on other platforms.
+
+To be portable it is advisable to rename the file.
+
+If you know what you are doing you can disable this check using:
+
+ git config hooks.allownonascii true
+EOF
+	exit 1
+fi
+
+# If there are whitespace errors, print the offending file names and fail.
+exec git diff-index --check --cached $against --

guam-0.9.11.tar.gz/_checkouts/syslog/.git/hooks/pre-merge-commit.sample Added

guam-0.9.11.tar.gz/_checkouts/syslog/.git/hooks/pre-push.sample Added

@@ -0,0 +1,53 @@
+#!/usr/bin/sh
+
+# An example hook script to verify what is about to be pushed. Called by "git
+# push" after it has checked the remote status, but before anything has been
+# pushed. If this script exits with a non-zero status nothing will be pushed.
+#
+# This hook is called with the following parameters:
+#
+# $1 -- Name of the remote to which the push is being done
+# $2 -- URL to which the push is being done
+#
+# If pushing without using a named remote those arguments will be equal.
+#
+# Information about the commits which are being pushed is supplied as lines to
+# the standard input in the form:
+#
+# <local ref> <local oid> <remote ref> <remote oid>
+#
+# This sample shows how to prevent push of commits where the log message starts
+# with "WIP" (work in progress).
+
+remote="$1"
+url="$2"
+
+zero=$(git hash-object --stdin </dev/null | tr '[0-9a-f]' '0')
+
+while read local_ref local_oid remote_ref remote_oid
+do
+	if test "$local_oid" = "$zero"
+	then
+		# Handle delete
+		:
+	else
+		if test "$remote_oid" = "$zero"
+		then
+			# New branch, examine all commits
+			range="$local_oid"
+		else
+			# Update to existing branch, examine new commits
+			range="$remote_oid..$local_oid"
+		fi
+
+		# Check for WIP commit
+		commit=$(git rev-list -n 1 --grep '^WIP' "$range")
+		if test -n "$commit"
+		then
+			echo >&2 "Found WIP commit in $local_ref, not pushing"
+			exit 1
+		fi
+	fi
+done
+
+exit 0

guam-0.9.11.tar.gz/_checkouts/syslog/.git/hooks/pre-rebase.sample Added

@@ -0,0 +1,169 @@
+#!/usr/bin/sh
+#
+# Copyright (c) 2006, 2008 Junio C Hamano
+#
+# The "pre-rebase" hook is run just before "git rebase" starts doing
+# its job, and can prevent the command from running by exiting with
+# non-zero status.
+#
+# The hook is called with the following parameters:
+#
+# $1 -- the upstream the series was forked from.
+# $2 -- the branch being rebased (or empty when rebasing the current branch).
+#
+# This sample shows how to prevent topic branches that are already
+# merged to 'next' branch from getting rebased, because allowing it
+# would result in rebasing already published history.
+
+publish=next
+basebranch="$1"
+if test "$#" = 2
+then
+	topic="refs/heads/$2"
+else
+	topic=`git symbolic-ref HEAD` ||
+	exit 0 ;# we do not interrupt rebasing detached HEAD
+fi
+
+case "$topic" in
+refs/heads/??/*)
+	;;
+*)
+	exit 0 ;# we do not interrupt others.
+	;;
+esac
+
+# Now we are dealing with a topic branch being rebased
+# on top of master. Is it OK to rebase it?
+
+# Does the topic really exist?
+git show-ref -q "$topic" || {
+	echo >&2 "No such branch $topic"
+	exit 1
+}
+
+# Is topic fully merged to master?
+not_in_master=`git rev-list --pretty=oneline ^master "$topic"`
+if test -z "$not_in_master"
+then
+	echo >&2 "$topic is fully merged to master; better remove it."
+	exit 1 ;# we could allow it, but there is no point.
+fi
+
+# Is topic ever merged to next? If so you should not be rebasing it.
+only_next_1=`git rev-list ^master "^$topic" ${publish} | sort`
+only_next_2=`git rev-list ^master ${publish} | sort`
+if test "$only_next_1" = "$only_next_2"
+then
+	not_in_topic=`git rev-list "^$topic" master`
+	if test -z "$not_in_topic"
+	then
+		echo >&2 "$topic is already up to date with master"
+		exit 1 ;# we could allow it, but there is no point.
+	else
+		exit 0
+	fi
+else
+	not_in_next=`git rev-list --pretty=oneline ^${publish} "$topic"`
+	/usr/bin/perl -e '
+		my $topic = $ARGV[0];
+		my $msg = "* $topic has commits already merged to public branch:\n";
+		my (%not_in_next) = map {
+			/^([0-9a-f]+) /;
+			($1 => 1);
+		} split(/\n/, $ARGV[1]);
+		for my $elem (map {
+				/^([0-9a-f]+) (.*)$/;
+				[$1 => $2];
+			} split(/\n/, $ARGV[2])) {
+			if (!exists $not_in_next{$elem->[0]}) {
+				if ($msg) {
+					print STDERR $msg;
+					undef $msg;
+				}
+				print STDERR " $elem->[1]\n";
+			}
+		}
+	' "$topic" "$not_in_next" "$not_in_master"
+	exit 1
+fi
+
+<<\DOC_END
+
+This sample hook safeguards topic branches that have been
+published from being rewound.
+
+The workflow assumed here is:
+
+ * Once a topic branch forks from "master", "master" is never
+ merged into it again (either directly or indirectly).
+
+ * Once a topic branch is fully cooked and merged into "master",
+ it is deleted. If you need to build on top of it to correct
+ earlier mistakes, a new topic branch is created by forking at
+ the tip of the "master". This is not strictly necessary, but
+ it makes it easier to keep your history simple.
+
+ * Whenever you need to test or publish your changes to topic
+ branches, merge them into "next" branch.
+
+The script, being an example, hardcodes the publish branch name
+to be "next", but it is trivial to make it configurable via
+$GIT_DIR/config mechanism.
+
+With this workflow, you would want to know:
+
+(1) ... if a topic branch has ever been merged to "next". Young
+ topic branches can have stupid mistakes you would rather
+ clean up before publishing, and things that have not been
+ merged into other branches can be easily rebased without
+ affecting other people. But once it is published, you would
+ not want to rewind it.
+
+(2) ... if a topic branch has been fully merged to "master".
+ Then you can delete it. More importantly, you should not
+ build on top of it -- other people may already want to
+ change things related to the topic as patches against your
+ "master", so if you need further changes, it is better to
+ fork the topic (perhaps with the same name) afresh from the
+ tip of "master".
+
+Let's look at this example:
+
+		 o---o---o---o---o---o---o---o---o---o "next"
+		 / / / /
+		 / a---a---b A / /
+		/ / / /
+	 / / c---c---c---c B /
+	 / / / \ /
+	 / / / b---b C \ /
+	 / / / / \ /
+ ---o---o---o---o---o---o---o---o---o---o---o "master"
+
+
+A, B and C are topic branches.
+
+ * A has one fix since it was merged up to "next".
+
+ * B has finished. It has been fully merged up to "master" and "next",
+ and is ready to be deleted.
+
+ * C has not merged to "next" at all.
+
+We would want to allow C to be rebased, refuse A, and encourage
+B to be deleted.
+
+To compute (1):
+
+	git rev-list ^master ^topic next
+	git rev-list ^master next
+
+	if these match, topic has not merged in next at all.
+
+To compute (2):
+
+	git rev-list master..topic
+
+	if this is empty, it is fully merged to "master".
+
+DOC_END

guam-0.9.11.tar.gz/_checkouts/syslog/.git/hooks/pre-receive.sample Added

guam-0.9.11.tar.gz/_checkouts/syslog/.git/hooks/prepare-commit-msg.sample Added

@@ -0,0 +1,42 @@
+#!/usr/bin/sh
+#
+# An example hook script to prepare the commit log message.
+# Called by "git commit" with the name of the file that has the
+# commit message, followed by the description of the commit
+# message's source.  The hook's purpose is to edit the commit
+# message file.  If the hook fails with a non-zero status,
+# the commit is aborted.
+#
+# To enable this hook, rename this file to "prepare-commit-msg".
+
+# This hook includes three examples. The first one removes the
+# "# Please enter the commit message..." help message.
+#
+# The second includes the output of "git diff --name-status -r"
+# into the message, just before the "git status" output.  It is
+# commented because it doesn't cope with --amend or with squashed
+# commits.
+#
+# The third example adds a Signed-off-by line to the message, that can
+# still be edited.  This is rarely a good idea.
+
+COMMIT_MSG_FILE=$1
+COMMIT_SOURCE=$2
+SHA1=$3
+
+/usr/bin/perl -i.bak -ne 'print unless(m/^. Please enter the commit message/..m/^#$/)' "$COMMIT_MSG_FILE"
+
+# case "$COMMIT_SOURCE,$SHA1" in
+#  ,|template,)
+#    /usr/bin/perl -i.bak -pe '
+#       print "\n" . `git diff --cached --name-status -r`
+# 	 if /^#/ && $first++ == 0' "$COMMIT_MSG_FILE" ;;
+#  *) ;;
+# esac
+
+# SOB=$(git var GIT_COMMITTER_IDENT | sed -n 's/^$.*>$.*$/Signed-off-by: \1/p')
+# git interpret-trailers --in-place --trailer "$SOB" "$COMMIT_MSG_FILE"
+# if test -z "$COMMIT_SOURCE"
+# then
+#   /usr/bin/perl -i.bak -pe 'print "\n" if !$first_line++' "$COMMIT_MSG_FILE"
+# fi

guam-0.9.11.tar.gz/_checkouts/syslog/.git/hooks/push-to-checkout.sample Added

@@ -0,0 +1,78 @@
+#!/usr/bin/sh
+
+# An example hook script to update a checked-out tree on a git push.
+#
+# This hook is invoked by git-receive-pack(1) when it reacts to git
+# push and updates reference(s) in its repository, and when the push
+# tries to update the branch that is currently checked out and the
+# receive.denyCurrentBranch configuration variable is set to
+# updateInstead.
+#
+# By default, such a push is refused if the working tree and the index
+# of the remote repository has any difference from the currently
+# checked out commit; when both the working tree and the index match
+# the current commit, they are updated to match the newly pushed tip
+# of the branch. This hook is to be used to override the default
+# behaviour; however the code below reimplements the default behaviour
+# as a starting point for convenient modification.
+#
+# The hook receives the commit with which the tip of the current
+# branch is going to be updated:
+commit=$1
+
+# It can exit with a non-zero status to refuse the push (when it does
+# so, it must not modify the index or the working tree).
+die () {
+	echo >&2 "$*"
+	exit 1
+}
+
+# Or it can make any necessary changes to the working tree and to the
+# index to bring them to the desired state when the tip of the current
+# branch is updated to the new commit, and exit with a zero status.
+#
+# For example, the hook can simply run git read-tree -u -m HEAD "$1"
+# in order to emulate git fetch that is run in the reverse direction
+# with git push, as the two-tree form of git read-tree -u -m is
+# essentially the same as git switch or git checkout that switches
+# branches while keeping the local changes in the working tree that do
+# not interfere with the difference between the branches.
+
+# The below is a more-or-less exact translation to shell of the C code
+# for the default behaviour for git's push-to-checkout hook defined in
+# the push_to_deploy() function in builtin/receive-pack.c.
+#
+# Note that the hook will be executed from the repository directory,
+# not from the working tree, so if you want to perform operations on
+# the working tree, you will have to adapt your code accordingly, e.g.
+# by adding "cd .." or using relative paths.
+
+if ! git update-index -q --ignore-submodules --refresh
+then
+	die "Up-to-date check failed"
+fi
+
+if ! git diff-files --quiet --ignore-submodules --
+then
+	die "Working directory has unstaged changes"
+fi
+
+# This is a rough translation of:
+#
+# head_has_history() ? "HEAD" : EMPTY_TREE_SHA1_HEX
+if git cat-file -e HEAD 2>/dev/null
+then
+	head=HEAD
+else
+	head=$(git hash-object -t tree --stdin </dev/null)
+fi
+
+if ! git diff-index --quiet --cached --ignore-submodules $head --
+then
+	die "Working directory has staged changes"
+fi
+
+if ! git read-tree -u -m "$commit"
+then
+	die "Could not update working tree to new HEAD"
+fi

guam-0.9.11.tar.gz/_checkouts/syslog/.git/hooks/update.sample Added

@@ -0,0 +1,128 @@
+#!/usr/bin/sh
+#
+# An example hook script to block unannotated tags from entering.
+# Called by "git receive-pack" with arguments: refname sha1-old sha1-new
+#
+# To enable this hook, rename this file to "update".
+#
+# Config
+# ------
+# hooks.allowunannotated
+# This boolean sets whether unannotated tags will be allowed into the
+# repository. By default they won't be.
+# hooks.allowdeletetag
+# This boolean sets whether deleting tags will be allowed in the
+# repository. By default they won't be.
+# hooks.allowmodifytag
+# This boolean sets whether a tag may be modified after creation. By default
+# it won't be.
+# hooks.allowdeletebranch
+# This boolean sets whether deleting branches will be allowed in the
+# repository. By default they won't be.
+# hooks.denycreatebranch
+# This boolean sets whether remotely creating branches will be denied
+# in the repository. By default this is allowed.
+#
+
+# --- Command line
+refname="$1"
+oldrev="$2"
+newrev="$3"
+
+# --- Safety check
+if [ -z "$GIT_DIR" ]; then
+	echo "Don't run this script from the command line." >&2
+	echo " (if you want, you could supply GIT_DIR then run" >&2
+	echo " $0 <ref> <oldrev> <newrev>)" >&2
+	exit 1
+fi
+
+if [ -z "$refname" -o -z "$oldrev" -o -z "$newrev" ]; then
+	echo "usage: $0 <ref> <oldrev> <newrev>" >&2
+	exit 1
+fi
+
+# --- Config
+allowunannotated=$(git config --type=bool hooks.allowunannotated)
+allowdeletebranch=$(git config --type=bool hooks.allowdeletebranch)
+denycreatebranch=$(git config --type=bool hooks.denycreatebranch)
+allowdeletetag=$(git config --type=bool hooks.allowdeletetag)
+allowmodifytag=$(git config --type=bool hooks.allowmodifytag)
+
+# check for no description
+projectdesc=$(sed -e '1q' "$GIT_DIR/description")
+case "$projectdesc" in
+"Unnamed repository"* | "")
+	echo "*** Project description file hasn't been set" >&2
+	exit 1
+	;;
+esac
+
+# --- Check types
+# if $newrev is 0000...0000, it's a commit to delete a ref.
+zero=$(git hash-object --stdin </dev/null | tr '[0-9a-f]' '0')
+if [ "$newrev" = "$zero" ]; then
+	newrev_type=delete
+else
+	newrev_type=$(git cat-file -t $newrev)
+fi
+
+case "$refname","$newrev_type" in
+	refs/tags/*,commit)
+		# un-annotated tag
+		short_refname=${refname##refs/tags/}
+		if [ "$allowunannotated" != "true" ]; then
+			echo "*** The un-annotated tag, $short_refname, is not allowed in this repository" >&2
+			echo "*** Use 'git tag [ -a | -s ]' for tags you want to propagate." >&2
+			exit 1
+		fi
+		;;
+	refs/tags/*,delete)
+		# delete tag
+		if [ "$allowdeletetag" != "true" ]; then
+			echo "*** Deleting a tag is not allowed in this repository" >&2
+			exit 1
+		fi
+		;;
+	refs/tags/*,tag)
+		# annotated tag
+		if [ "$allowmodifytag" != "true" ] && git rev-parse $refname > /dev/null 2>&1
+		then
+			echo "*** Tag '$refname' already exists." >&2
+			echo "*** Modifying a tag is not allowed in this repository." >&2
+			exit 1
+		fi
+		;;
+	refs/heads/*,commit)
+		# branch
+		if [ "$oldrev" = "$zero" -a "$denycreatebranch" = "true" ]; then
+			echo "*** Creating a branch is not allowed in this repository" >&2
+			exit 1
+		fi
+		;;
+	refs/heads/*,delete)
+		# delete branch
+		if [ "$allowdeletebranch" != "true" ]; then
+			echo "*** Deleting a branch is not allowed in this repository" >&2
+			exit 1
+		fi
+		;;
+	refs/remotes/*,commit)
+		# tracking branch
+		;;
+	refs/remotes/*,delete)
+		# delete tracking branch
+		if [ "$allowdeletebranch" != "true" ]; then
+			echo "*** Deleting a tracking branch is not allowed in this repository" >&2
+			exit 1
+		fi
+		;;
+	*)
+		# Anything else (is there anything else?)
+		echo "*** Update hook: unknown type of update to ref $refname of type $newrev_type" >&2
+		exit 1
+		;;
+esac
+
+# --- Finished
+exit 0

guam-0.9.11.tar.gz/_checkouts/syslog/.git/index Added

guam-0.9.11.tar.gz/_checkouts/syslog/.git/info Added

guam-0.9.11.tar.gz/_checkouts/syslog/.git/info/exclude Added

guam-0.9.11.tar.gz/_checkouts/syslog/.git/logs Added

guam-0.9.11.tar.gz/_checkouts/syslog/.git/logs/HEAD Added

guam-0.9.11.tar.gz/_checkouts/syslog/.git/logs/refs Added

guam-0.9.11.tar.gz/_checkouts/syslog/.git/logs/refs/heads Added

guam-0.9.11.tar.gz/_checkouts/syslog/.git/logs/refs/heads/master Added

guam-0.9.11.tar.gz/_checkouts/syslog/.git/logs/refs/remotes Added

guam-0.9.11.tar.gz/_checkouts/syslog/.git/logs/refs/remotes/origin Added

guam-0.9.11.tar.gz/_checkouts/syslog/.git/logs/refs/remotes/origin/HEAD Added

guam-0.9.11.tar.gz/_checkouts/syslog/.git/objects Added

guam-0.9.11.tar.gz/_checkouts/syslog/.git/objects/info Added

guam-0.9.11.tar.gz/_checkouts/syslog/.git/objects/pack Added

guam-0.9.11.tar.gz/_checkouts/syslog/.git/objects/pack/pack-530f2da589c2a7d368d96293bdcc65385e9d957a.idx Added

guam-0.9.11.tar.gz/_checkouts/syslog/.git/objects/pack/pack-530f2da589c2a7d368d96293bdcc65385e9d957a.pack Added

guam-0.9.11.tar.gz/_checkouts/syslog/.git/packed-refs Added

guam-0.9.11.tar.gz/_checkouts/syslog/.git/refs Added

guam-0.9.11.tar.gz/_checkouts/syslog/.git/refs/heads Added

guam-0.9.11.tar.gz/_checkouts/syslog/.git/refs/heads/master Added

guam-0.9.11.tar.gz/_checkouts/syslog/.git/refs/remotes Added

guam-0.9.11.tar.gz/_checkouts/syslog/.git/refs/remotes/origin Added

guam-0.9.11.tar.gz/_checkouts/syslog/.git/refs/remotes/origin/HEAD Added

guam-0.9.11.tar.gz/_checkouts/syslog/.git/refs/tags Added

guam-0.9.11.tar.gz/_checkouts/syslog/.git/refs/tags/0.0.1 Added

guam-0.9.11.tar.gz/_checkouts/syslog/.git/refs/tags/1.0.0 Added

guam-0.9.11.tar.gz/_checkouts/syslog/.git/refs/tags/1.0.1 Added

guam-0.9.11.tar.gz/_checkouts/syslog/.git/refs/tags/1.0.2 Added

guam-0.9.11.tar.gz/_checkouts/syslog/.git/refs/tags/1.0.3 Added

guam-0.9.11.tar.gz/_checkouts/syslog/.git/refs/tags/1.0.4 Added

guam-0.9.11.tar.gz/_checkouts/syslog/.git/refs/tags/1.0.5 Added

guam-0.9.11.tar.gz/_checkouts/syslog/.gitignore Added

guam-0.9.11.tar.gz/_checkouts/syslog/LICENSE Added

@@ -0,0 +1,22 @@
+Copyright 2009-2017 Andrew Thompson <andrew@hijacked.us>. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+ this list of conditions and the following disclaimer.
+ 2. Redistributions in binary form must reproduce the above copyright
+ notice, this list of conditions and the following disclaimer in the
+ documentation and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE PROJECT ``AS IS'' AND ANY EXPRESS OR
+IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
+EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
+INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+

guam-0.9.11.tar.gz/_checkouts/syslog/README.md Added

@@ -0,0 +1,107 @@
+Erlang driver for syslog
+------------------------
+
+This is an erlang port driver for interacting with syslog.
+
+Installing it
+-------------
+
+    ./rebar3 compile
+
+Trying it
+---------
+
+You should have a look at syslog.h.
+
+In another shell :
+
+    $ tail -f /var/log/syslog
+
+Or, for mac users :
+
+    $ tail -f /var/log/system.log
+
+In erlang shell :
+
+    $ erl
+    > syslog:start().
+    > {ok,Log} = syslog:open("Beuha", [cons, perror, pid], local0).
+    > syslog:log(Log, err, "Damned").
+    > syslog:log(Log, info, "process count: ~w", [length(processes())]).
+
+API
+---
+
+### syslog:open(Ident, Logopt, Facility) -> {ok, port()} ###
+
+_Ident_ is an arbitrary string  
+_Logopt_ is an atom or array of atom, you can use a number if you're brave enough :
+
+ * pid
+ * cons
+ * odelay
+ * ndelay
+ * perror
+
+_Facility_ is an atom :
+
+ * kern
+ * user
+ * mail
+ * daemon
+ * auth
+ * syslog
+ * lpr
+ * news
+ * uucp
+ * cron
+ * authpriv
+ * ftp
+ * netinfo
+ * remoteauth
+ * install
+ * ras
+ * local0
+ * local1
+ * local2
+ * local3
+ * local4
+ * local5
+ * local6
+ * local7
+
+The `open` call returns either `{ok, Log}` where _Log_ is a syslog handle
+that can be passed to subsequent `log` and `close` calls, or it will throw
+{error, badarg}.
+
+### syslog:log(Log, Priority, Message) -> ok ###
+
+_Log_ is a syslog handle returned from `open`  
+_Priority_ can be a number or better, an atom :
+
+ * emerg
+ * alert
+ * crit
+ * err
+ * warning
+ * notice
+ * info
+ * debug
+
+_Message_ is a string.
+
+### syslog:log(Log, Priority, FormatMsg, FormatArgs) -> ok ###
+
+Same as above, but allows for the construction of log messages similar to
+formatting strings via `io_lib:format/2`, where _FormatMsg_ indicates the
+formatting instructions and _FormatArgs_ is a list of arguments to be
+formatted.
+
+### syslog:close(Log) -> ok ###
+
+_Log_ is a syslog handle returned from `open`
+
+BUGS
+----
+
+ * None known

guam-0.9.11.tar.gz/_checkouts/syslog/c_src Added

guam-0.9.11.tar.gz/_checkouts/syslog/c_src/syslog_drv.c Added

@@ -0,0 +1,182 @@
+/*
+Copyright 2009 Andrew Thompson <andrew@hijacked.us>. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+ this list of conditions and the following disclaimer.
+ 2. Redistributions in binary form must reproduce the above copyright
+ notice, this list of conditions and the following disclaimer in the
+ documentation and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR
+IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
+EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
+INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+#include <stdint.h>
+#include <syslog.h>
+#include <stdarg.h>
+#include <string.h>
+
+#include <ei.h>
+#include <erl_driver.h>
+
+/* for pre-R15 compatibility */
+#if ERL_DRV_EXTENDED_MAJOR_VERSION < 2
+typedef int ErlDrvSizeT;
+typedef int ErlDrvSSizeT;
+#endif
+
+#define DRV_NAME "syslog_drv"
+
+/* the following constants have to match those in syslog.erl */
+#define SYSLOGDRV_OPEN 1
+#define SYSLOGDRV_CLOSE 2
+
+struct syslogdrv {
+ ErlDrvPort port;
+ char *ident;
+ int logopt;
+ int facility;
+ unsigned char open;
+};
+
+typedef struct syslogdrv syslogdrv_t;
+
+static ErlDrvSSizeT encode_error(char* buf, char* error) {
+ int index = 0;
+ if (ei_encode_version(buf, &index) ||
+ ei_encode_tuple_header(buf, &index, 2) ||
+ ei_encode_atom(buf, &index, "error") ||
+ ei_encode_atom(buf, &index, error)) {
+ return (ErlDrvSSizeT)ERL_DRV_ERROR_GENERAL;
+ }
+ return index+1;
+}
+
+static ErlDrvData syslogdrv_start(ErlDrvPort port, char *buf)
+{
+ syslogdrv_t* d = (syslogdrv_t*)driver_alloc(sizeof(syslogdrv_t));
+ d->port = port;
+ d->open = 0;
+ d->ident = NULL;
+ set_port_control_flags(port, PORT_CONTROL_FLAG_BINARY);
+ return (ErlDrvData)d;
+}
+
+static void syslogdrv_stop(ErlDrvData handle)
+{
+ syslogdrv_t* d = (syslogdrv_t*)handle;
+ closelog();
+ if (d->ident) {
+ driver_free(d->ident);
+ }
+ driver_free((char*)handle);
+}
+
+static void syslogdrv_output(ErlDrvData handle, char *buf, ErlDrvSizeT len)
+{
+ syslogdrv_t* d = (syslogdrv_t*)handle;
+ /* Incoming data is expected to start with an integer priority encoded
+ as a 4-byte integer in network order, therefore make sure there's at
+ least 5 bytes in the message. */
+ if (d->open && len > 4) {
+ int priority = ntohl(*(uint32_t*)buf);
+ buf += 4;
+ /* re-call openlog in case another instance of the port driver
+ * was called in the mean time */
+ openlog(d->ident, d->logopt, d->facility);
+ syslog(priority, "%s", buf);
+ }
+}
+
+static ErlDrvSSizeT syslogdrv_control(ErlDrvData handle, unsigned int command,
+ char *buf, ErlDrvSizeT len,
+ char **rbuf, ErlDrvSizeT rlen)
+{
+ syslogdrv_t* d = (syslogdrv_t*)handle;
+ if (d->open) {
+ return (ErlDrvSSizeT)ERL_DRV_ERROR_BADARG;
+ }
+ int index = 0, version, arity, type, size;
+
+ if (command != SYSLOGDRV_OPEN) {
+ return (ErlDrvSSizeT)ERL_DRV_ERROR_BADARG;
+ }
+
+ if (ei_decode_version(buf, &index, &version)) {
+ return encode_error(*rbuf, "badver");
+ }
+ if (ei_decode_tuple_header(buf, &index, &arity) || arity != 3) {
+ return (ErlDrvSSizeT)ERL_DRV_ERROR_BADARG;
+ }
+ if (ei_get_type(buf, &index, &type, &size)) {
+ return (ErlDrvSSizeT)ERL_DRV_ERROR_BADARG;
+ }
+ if (type == ERL_STRING_EXT) {
+ long logopt, facility;
+
+ if (d->ident) {
+ driver_free(d->ident);
+ }
+ d->ident = driver_alloc(size+1);
+ if (d->ident == NULL) {
+ return encode_error(*rbuf, "enomem");
+ }
+ if (ei_decode_string(buf, &index, d->ident)) {
+ return (ErlDrvSSizeT)ERL_DRV_ERROR_BADARG;
+ }
+ if (ei_decode_long(buf, &index, &logopt) ||
+ ei_decode_long(buf, &index, &facility)) {
+ return (ErlDrvSSizeT)ERL_DRV_ERROR_BADARG;
+ }
+ d->logopt = (int)logopt;
+ d->facility = (int)facility;
+ d->open = 1;
+ return 0;
+ } else {
+ return (ErlDrvSSizeT)ERL_DRV_ERROR_BADARG;
+ }
+}
+
+/*
+ * Initialize and return a driver entry struct
+ */
+static ErlDrvEntry syslogdrv_driver_entry = {
+ NULL,
+ syslogdrv_start,
+ syslogdrv_stop,
+ syslogdrv_output,
+ NULL,
+ NULL,
+ DRV_NAME,
+ NULL,
+ NULL,
+ syslogdrv_control,
+ NULL,
+ NULL,
+ NULL,
+ NULL,
+ NULL,
+ NULL,
+ ERL_DRV_EXTENDED_MARKER,
+ ERL_DRV_EXTENDED_MAJOR_VERSION,
+ ERL_DRV_EXTENDED_MINOR_VERSION,
+ 0,
+ NULL,
+ NULL,
+ NULL,
+};
+
+DRIVER_INIT(syslogdrv)
+{
+ return &syslogdrv_driver_entry;
+}

guam-0.9.11.tar.gz/_checkouts/syslog/rebar.config Added

guam-0.9.11.tar.gz/_checkouts/syslog/rebar.lock Added

guam-0.9.11.tar.gz/_checkouts/syslog/src Added

guam-0.9.11.tar.gz/_checkouts/syslog/src/syslog.app.src Added

guam-0.9.11.tar.gz/_checkouts/syslog/src/syslog.erl Added

@@ -0,0 +1,318 @@
+%%% Copyright 2009 Andrew Thompson <andrew@hijacked.us>. All rights reserved.
+%%%
+%%% Redistribution and use in source and binary forms, with or without
+%%% modification, are permitted provided that the following conditions are met:
+%%%
+%%% 1. Redistributions of source code must retain the above copyright notice,
+%%% this list of conditions and the following disclaimer.
+%%% 2. Redistributions in binary form must reproduce the above copyright
+%%% notice, this list of conditions and the following disclaimer in the
+%%% documentation and/or other materials provided with the distribution.
+%%%
+%%% THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR
+%%% IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+%%% MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
+%%% EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
+%%% INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+%%% (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+%%% LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+%%% ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+%%% (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+%%% SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+%% @doc erlang wrapper for syslog port
+
+-module(syslog).
+
+-behaviour(gen_server).
+
+-define(DRV_NAME, "syslog_drv").
+
+%% this constant must match the same in syslog_drv.c
+-define(SYSLOGDRV_OPEN, 1).
+
+%% API
+-export([
+ start/0,
+ start_link/0,
+ stop/0,
+ open/3,
+ log/3,
+ log/4,
+ close/1,
+ priority/1,
+ facility/1,
+ openlog_opt/1,
+ openlog_opts/1,
+ load/0,
+ unload/0
+ ]).
+
+%% gen_server callbacks
+-export([
+ init/1,
+ handle_call/3,
+ handle_cast/2,
+ handle_info/2,
+ terminate/2,
+ code_change/3
+ ]).
+
+-ifdef(TEST).
+-include_lib("eunit/include/eunit.hrl").
+-endif.
+
+-record(state, {}).
+
+-type priority() :: emerg | alert | crit | err |
+ warning | notice | info | debug | non_neg_integer().
+-type facility() :: kern | user | mail | daemon | auth | syslog |
+ lpr | news | uucp | cron | authpriv | ftp |
+ netinfo | remoteauth | install | ras |
+ local0 | local1 | local2 | local3 |
+ local4 | local5 | local6 | local7 | non_neg_integer().
+-type openlog_opt() :: pid | cons | odelay | ndelay | perror | pos_integer().
+-export_type([priority/0, facility/0, openlog_opt/0]).
+
+%%% API %%%
+
+-spec start() ->
+ {ok, pid()} | ignore | {error, any()}.
+
+start() ->
+ gen_server:start({local, ?MODULE}, ?MODULE, [], []).
+
+-spec start_link() ->
+ {ok, pid()} | ignore | {error, any()}.
+
+start_link() ->
+ gen_server:start_link({local, ?MODULE}, ?MODULE, [], []).
+
+-spec stop() ->
+ ok.
+
+stop() ->
+ gen_server:cast(?MODULE, stop).
+
+-spec open(Ident :: string(),
+ Logopt :: list(openlog_opt()),
+ Facility :: facility()) ->
+ {ok, port()} |
+ {error, any()}.
+
+open(Ident, Logopt, Facility) ->
+ Log = erlang:open_port({spawn, ?DRV_NAME}, [binary]),
+ Args = term_to_binary({Ident, openlog_opts(Logopt), facility(Facility)}),
+ try erlang:port_control(Log, ?SYSLOGDRV_OPEN, Args) of
+ <<>> ->
+ {ok, Log};
+ BinError ->
+ binary_to_term(BinError)
+ catch
+ _:Reason ->
+ {error, Reason}
+ end.
+
+-spec log(Log :: port(),
+ Priority :: priority(),
+ Message :: iolist()) ->
+ ok.
+
+log(_Log, _Priority, []) ->
+ ok;
+log(Log, Priority, Message) ->
+ NumPri = priority(Priority),
+ %% encode the priority value as a 4-byte integer in network order, and
+ %% add a 0 byte to the end of the command data to act as a NUL character
+ true = erlang:port_command(Log, [<<NumPri:32/big>>, Message, <<0:8>>]),
+ ok.
+
+-spec log(Log :: port(),
+ Priority :: priority(),
+ FormatStr :: string(),
+ FormatArgs :: list()) ->
+ ok.
+
+log(Log, Priority, FormatStr, FormatArgs) ->
+ log(Log, Priority, io_lib:format(FormatStr, FormatArgs)).
+
+-spec close(Log :: port()) ->
+ ok.
+
+close(Log) ->
+ true = erlang:port_close(Log),
+ ok.
+
+-spec priority(N :: priority() | non_neg_integer()) ->
+ non_neg_integer().
+
+priority(emerg) -> 0;
+priority(alert) -> 1;
+priority(crit) -> 2;
+priority(err) -> 3;
+priority(warning) -> 4;
+priority(notice) -> 5;
+priority(info) -> 6;
+priority(debug) -> 7;
+priority(N) when is_integer(N), N >= 0 -> N;
+priority(_) -> erlang:error(badarg).
+
+-spec facility(N :: facility() | non_neg_integer()) ->
+ non_neg_integer().
+
+facility(kern) -> 0;
+facility(user) -> 8;
+facility(mail) -> 16;
+facility(daemon) -> 24;
+facility(auth) -> 32;
+facility(syslog) -> 40;
+facility(lpr) -> 48;
+facility(news) -> 56;
+facility(uucp) -> 64;
+facility(cron) -> 72;
+facility(authpriv) -> 80;
+facility(ftp) -> 88;
+facility(netinfo) -> 96;
+facility(remoteauth)-> 104;
+facility(install) -> 112;
+facility(ras) -> 120;
+facility(local0) -> 16 * 8;
+facility(local1) -> 17 * 8;
+facility(local2) -> 18 * 8;
+facility(local3) -> 19 * 8;
+facility(local4) -> 20 * 8;
+facility(local5) -> 21 * 8;
+facility(local6) -> 22 * 8;
+facility(local7) -> 23 * 8;
+facility(N) when is_integer(N), N >= 0 -> N;
+facility(_) -> erlang:error(badarg).
+
+-spec openlog_opt(N :: openlog_opt() | pos_integer()) ->
+ pos_integer().
+
+openlog_opt(pid) -> 1;
+openlog_opt(cons) -> 2;
+openlog_opt(odelay) -> 4;
+openlog_opt(ndelay) -> 8;
+openlog_opt(perror) -> 20;
+openlog_opt(N) when is_integer(N), N >= 1 -> N;
+openlog_opt(_) -> erlang:error(badarg).
+
+-spec openlog_opts(N :: list(openlog_opt() | pos_integer()) |
+ openlog_opt() | pos_integer()) ->
+ pos_integer().
+
+openlog_opts([Queue]) -> openlog_opt(Queue);
+openlog_opts([Tail|Queue]) ->
+ openlog_opt(Tail) bor openlog_opts(Queue);
+openlog_opts([]) -> 0;
+openlog_opts(N) -> openlog_opt(N).
+
+-spec load() ->
+ ok | {error, string()}.
+
+load() ->
+ PrivDir = case code:priv_dir(?MODULE) of
+ {error, bad_name} ->
+ EbinDir = filename:dirname(code:which(?MODULE)),
+ AppPath = filename:dirname(EbinDir),
+ filename:join(AppPath, "priv");
+ Path ->
+ Path
+ end,
+ case erl_ddll:load_driver(PrivDir, ?DRV_NAME) of
+ ok -> ok;
+ {error, already_loaded} -> ok;
+ {error, LoadError} ->
+ LoadErrorStr = erl_ddll:format_error(LoadError),
+ ErrStr = lists:flatten(
+ io_lib:format("could not load driver ~s: ~p",
+ [?DRV_NAME, LoadErrorStr])),
+ {error, ErrStr}
+ end.
+
+-spec unload() ->
+ ok | {error, string()}.
+
+unload() ->
+ case erl_ddll:unload_driver(?DRV_NAME) of
+ ok -> ok;
+ {error, UnloadError} ->
+ UnloadErrorStr = erl_ddll:format_error(UnloadError),
+ ErrStr = lists:flatten(
+ io_lib:format("could not unload driver ~s: ~p",
+ [?DRV_NAME, UnloadErrorStr])),
+ {error, ErrStr}
+ end.
+
+%%% gen_server callbacks %%%
+
+init([]) ->
+ case load() of
+ ok ->
+ {ok, #state{}};
+ {error, Reason} ->
+ {stop, Reason}
+ end.
+
+handle_call(_Msg, _From, State) ->
+ {reply, ok, State}.
+
+handle_cast(stop, State) ->
+ {stop, normal, State};
+handle_cast(_Msg, State) ->
+ {noreply, State}.
+
+handle_info(_Info, State) ->
+ {noreply, State}.
+
+terminate(_Reason, _State) ->
+ ok.
+
+code_change(_, State, _) ->
+ {ok, State}.
+
+%%% internal functions %%%
+
+-ifdef(TEST).
+
+openlog_opts_test() ->
+ 11 = openlog_opts([1,2,8]),
+ 1 = openlog_opts(pid),
+ try
+ foo = openlog_opts(foo)
+ catch
+ error:badarg ->
+ ok;
+ Reason ->
+ throw(Reason)
+ end.
+
+closed_test() ->
+ {ok, _} = syslog:start(),
+ try
+ {ok, Log} = open("test", pid, local0),
+ Self = self(),
+ {connected,Self} = erlang:port_info(Log, connected),
+ ok = close(Log),
+ try
+ close(Log)
+ catch
+ error:badarg ->
+ ok;
+ Reason1 ->
+ throw(Reason1)
+ end,
+ try
+ ok = log(Log, 8, "writing to closed log")
+ catch
+ error:badarg ->
+ ok;
+ Reason2 ->
+ throw(Reason2)
+ end
+ after
+ syslog:stop()
+ end.
+
+-endif.

guam-0.9.11.tar.gz/_checkouts/syslog/src/syslog_app.erl Added

guam-0.9.11.tar.gz/_checkouts/syslog/src/syslog_sup.erl Added

guam-0.9.11.tar.gz/rebar.lock Deleted

Changes of Revision 8