idhowardgj94/1git.md

## 1git.md

      
    Raw
  

              1git.md
            
          
    任務：部屬一個不用認證密碼的環境


原因：部屬自動部屬環境，需要可以自動pull git 資料，不需密碼。
潛在風險：可能有安全性的疑慮（.netrc中的密碼為明碼，要設定好.netrc的讀取權險，目前只在測試server上使用。
git：使用bit。
參考： https://stackoverflow.com/questions/31609203/git-netrc-file-authentication-issue

步驟一、設定.netrc檔

# 到根目錄下
cd ~
# 新增一個檔案 .netrc
vi .netrc
.netrc中輸入以下的認証資料：
# bitbuckit server
machine bitbucket.org
login <your bitbucket user_id>
password <your bitbucket password>
安全性問題，儲存後要更改讀寫權限：
sudo chmod 600 .netrc
新增 git-credential-netrc 執行檔

我的做法是將這個檔案放到~/bin資料夾底下，如果沒有這個資料夾自己開一個：
# in ~/
mkdir bin
# copy or create git-credential-netrc
vi git-credential-netrc
chmod 777 git-credential-netrc
chmod 777 git-credential-netrc 是為了讓這個程式可執行。應該有更安全的狀態。這還要再試一下。
這個檔案在github的git專案底下：
https://github.com/git/git/blob/master/contrib/credential/netrc/git-credential-netrc
我是直接複製原始碼貼上。
修改git設定檔

修改git設定檔，主要是將https://<username>@bitbucket.com 前面的 <username>@ 刪掉，
這樣讀取.netrc時才對的上server name
# 專案目錄底下
vi .git/config
# [remote "origin"] 段
url = https://bitbucket.org/<sub_url>
增加crediential設定

# 專案目錄底下
git config credential.helper "netrc -d -v"
-d -v 為debug用，沒問題可以刪掉。
大功告成！

  
## deploy.sh
echo "clear untrack file..."
git clean -d -f &> /dev/null
echo "reset git to current version"
git reset --hard &> /dev/null
echo "pull git"....
git pull
echo "deploy environment..."
composer dump-autoload
npm install
npm run dev
echo "all done"

## git-credential-netrc
#!/usr/bin/perl

use strict;
use warnings;

use Getopt::Long;
use File::Basename;
use Git;

my $VERSION = "0.2";

my %options = (
	       help => 0,
	       debug => 0,
	       verbose => 0,
	       insecure => 0,
	       file => [],

	       # identical token maps, e.g. host -> host, will be inserted later
	       tmap => {
			port => 'protocol',
			machine => 'host',
			path => 'path',
			login => 'username',
			user => 'username',
			password => 'password',
		       }
	      );

# Map each credential protocol token to itself on the netrc side.
foreach (values %{$options{tmap}}) {
	$options{tmap}->{$_} = $_;
}

# Now, $options{tmap} has a mapping from the netrc format to the Git credential
# helper protocol.

# Next, we build the reverse token map.

# When $rmap{foo} contains 'bar', that means that what the Git credential helper
# protocol calls 'bar' is found as 'foo' in the netrc/authinfo file.  Keys in
# %rmap are what we expect to read from the netrc/authinfo file.

my %rmap;
foreach my $k (keys %{$options{tmap}}) {
	push @{$rmap{$options{tmap}->{$k}}}, $k;
}

Getopt::Long::Configure("bundling");

# TODO: maybe allow the token map $options{tmap} to be configurable.
GetOptions(\%options,
           "help|h",
           "debug|d",
           "insecure|k",
           "verbose|v",
           "file|f=s@",
           'gpg|g:s',
          );

if ($options{help}) {
	my $shortname = basename($0);
	$shortname =~ s/git-credential-//;

	print <<EOHIPPUS;
$0 [(-f <authfile>)...] [-g <program>] [-d] [-v] [-k] get
Version $VERSION by tzz\@lifelogs.com.  License: BSD.
Options:
  -f|--file <authfile>: specify netrc-style files.  Files with the .gpg
                        extension will be decrypted by GPG before parsing.
                        Multiple -f arguments are OK.  They are processed in
                        order, and the first matching entry found is returned
                        via the credential helper protocol (see below).
                        When no -f option is given, .authinfo.gpg, .netrc.gpg,
                        .authinfo, and .netrc files in your home directory are
                        used in this order.
  -g|--gpg <program>  : specify the program for GPG. By default, this is the
                        value of gpg.program in the git repository or global
                        option or gpg.
  -k|--insecure       : ignore bad file ownership or permissions
  -d|--debug          : turn on debugging (developer info)
  -v|--verbose        : be more verbose (show files and information found)
To enable this credential helper:
  git config credential.helper '$shortname -f AUTHFILE1 -f AUTHFILE2'
(Note that Git will prepend "git-credential-" to the helper name and look for it
in the path.)
...and if you want lots of debugging info:
  git config credential.helper '$shortname -f AUTHFILE -d'
...or to see the files opened and data found:
  git config credential.helper '$shortname -f AUTHFILE -v'
Only "get" mode is supported by this credential helper.  It opens every
<authfile> and looks for the first entry that matches the requested search
criteria:
 'port|protocol':
   The protocol that will be used (e.g., https). (protocol=X)
 'machine|host':
   The remote hostname for a network credential. (host=X)
 'path':
   The path with which the credential will be used. (path=X)
 'login|user|username':
   The credential’s username, if we already have one. (username=X)
Thus, when we get this query on STDIN:
host=github.com
protocol=https
username=tzz
this credential helper will look for the first entry in every <authfile> that
matches
machine github.com port https login tzz
OR
machine github.com protocol https login tzz
OR... etc. acceptable tokens as listed above.  Any unknown tokens are
simply ignored.
Then, the helper will print out whatever tokens it got from the entry, including
"password" tokens, mapping back to Git's helper protocol; e.g. "port" is mapped
back to "protocol".  Any redundant entry tokens (part of the original query) are
skipped.
Again, note that only the first matching entry from all the <authfile>s,
processed in the sequence given on the command line, is used.
Netrc/authinfo tokens can be quoted as 'STRING' or "STRING".
No caching is performed by this credential helper.
EOHIPPUS

	exit 0;
}

my $mode = shift @ARGV;

# Credentials must get a parameter, so die if it's missing.
die "Syntax: $0 [(-f <authfile>)...] [-d] get" unless defined $mode;

# Only support 'get' mode; with any other unsupported ones we just exit.
exit 0 unless $mode eq 'get';

my $files = $options{file};

# if no files were given, use a predefined list.
# note that .gpg files come first
unless (scalar @$files) {
	my @candidates = qw[
				   ~/.authinfo.gpg
				   ~/.netrc.gpg
				   ~/.authinfo
				   ~/.netrc
			  ];

	$files = $options{file} = [ map { glob $_ } @candidates ];
}

load_config(\%options);

my $query = read_credential_data_from_stdin();

FILE:
foreach my $file (@$files) {
	my $gpgmode = $file =~ m/\.gpg$/;
	unless (-r $file) {
		log_verbose("Unable to read $file; skipping it");
		next FILE;
	}

	# the following check is copied from Net::Netrc, for non-GPG files
	# OS/2 and Win32 do not handle stat in a way compatible with this check :-(
	unless ($gpgmode || $options{insecure} ||
		$^O eq 'os2'
		|| $^O eq 'MSWin32'
		|| $^O eq 'MacOS'
		|| $^O =~ /^cygwin/) {
		my @stat = stat($file);

		if (@stat) {
			if ($stat[2] & 077) {
				log_verbose("Insecure $file (mode=%04o); skipping it",
					    $stat[2] & 07777);
				next FILE;
			}

			if ($stat[4] != $<) {
				log_verbose("Not owner of $file; skipping it");
				next FILE;
			}
		}
	}

	my @entries = load_netrc($file, $gpgmode);

	unless (scalar @entries) {
		if ($!) {
			log_verbose("Unable to open $file: $!");
		} else {
			log_verbose("No netrc entries found in $file");
		}

		next FILE;
	}

	my $entry = find_netrc_entry($query, @entries);
	if ($entry) {
		print_credential_data($entry, $query);
		# we're done!
		last FILE;
	}
}

exit 0;

sub load_netrc {
	my $file = shift @_;
	my $gpgmode = shift @_;

	my $io;
	if ($gpgmode) {
		my @cmd = ($options{'gpg'}, qw(--decrypt), $file);
		log_verbose("Using GPG to open $file: [@cmd]");
		open $io, "-|", @cmd;
	} else {
		log_verbose("Opening $file...");
		open $io, '<', $file;
	}

	# nothing to do if the open failed (we log the error later)
	return unless $io;

	# Net::Netrc does this, but the functionality is merged with the file
	# detection logic, so we have to extract just the part we need
	my @netrc_entries = net_netrc_loader($io);

	# these entries will use the credential helper protocol token names
	my @entries;

	foreach my $nentry (@netrc_entries) {
		my %entry;
		my $num_port;

		if (!defined $nentry->{machine}) {
			next;
		}
		if (defined $nentry->{port} && $nentry->{port} =~ m/^\d+$/) {
			$num_port = $nentry->{port};
			delete $nentry->{port};
		}

		# create the new entry for the credential helper protocol
		$entry{$options{tmap}->{$_}} = $nentry->{$_} foreach keys %$nentry;

		# for "host X port Y" where Y is an integer (captured by
		# $num_port above), set the host to "X:Y"
		if (defined $entry{host} && defined $num_port) {
			$entry{host} = join(':', $entry{host}, $num_port);
		}

		push @entries, \%entry;
	}

	return @entries;
}

sub net_netrc_loader {
	my $fh = shift @_;
	my @entries;
	my ($mach, $macdef, $tok, @tok);

    LINE:
	while (<$fh>) {
		undef $macdef if /\A\n\Z/;

		if ($macdef) {
			next LINE;
		}

		s/^\s*//;
		chomp;

		while (length && s/^("((?:[^"]+|\\.)*)"|((?:[^\\\s]+|\\.)*))\s*//) {
			(my $tok = $+) =~ s/\\(.)/$1/g;
			push(@tok, $tok);
		}

	    TOKEN:
		while (@tok) {
			if ($tok[0] eq "default") {
				shift(@tok);
				$mach = { machine => undef };
				next TOKEN;
			}

			$tok = shift(@tok);

			if ($tok eq "machine") {
				my $host = shift @tok;
				$mach = { machine => $host };
				push @entries, $mach;
			} elsif (exists $options{tmap}->{$tok}) {
				unless ($mach) {
					log_debug("Skipping token $tok because no machine was given");
					next TOKEN;
				}

				my $value = shift @tok;
				unless (defined $value) {
					log_debug("Token $tok had no value, skipping it.");
					next TOKEN;
				}

				# Following line added by rmerrell to remove '/' escape char in .netrc
				$value =~ s/\/\\/\\/g;
				$mach->{$tok} = $value;
			} elsif ($tok eq "macdef") { # we ignore macros
				next TOKEN unless $mach;
				my $value = shift @tok;
				$macdef = 1;
			}
		}
	}

	return @entries;
}

sub read_credential_data_from_stdin {
	# the query: start with every token with no value
	my %q = map { $_ => undef } values(%{$options{tmap}});

	while (<STDIN>) {
		next unless m/^([^=]+)=(.+)/;

		my ($token, $value) = ($1, $2);
		die "Unknown search token $token" unless exists $q{$token};
		$q{$token} = $value;
		log_debug("We were given search token $token and value $value");
	}

	foreach (sort keys %q) {
		log_debug("Searching for %s = %s", $_, $q{$_} || '(any value)');
	}

	return \%q;
}

# takes the search tokens and then a list of entries
# each entry is a hash reference
sub find_netrc_entry {
	my $query = shift @_;

    ENTRY:
	foreach my $entry (@_)
	{
		my $entry_text = join ', ', map { "$_=$entry->{$_}" } keys %$entry;
		foreach my $check (sort keys %$query) {
			if (!defined $entry->{$check}) {
			        log_debug("OK: entry has no $check token, so any value satisfies check $check");
			} elsif (defined $query->{$check}) {
				log_debug("compare %s [%s] to [%s] (entry: %s)",
					  $check,
					  $entry->{$check},
					  $query->{$check},
					  $entry_text);
				unless ($query->{$check} eq $entry->{$check}) {
					next ENTRY;
				}
			} else {
				log_debug("OK: any value satisfies check $check");
			}
		}

		return $entry;
	}

	# nothing was found
	return;
}

sub print_credential_data {
	my $entry = shift @_;
	my $query = shift @_;

	log_debug("entry has passed all the search checks");
 TOKEN:
	foreach my $git_token (sort keys %$entry) {
		log_debug("looking for useful token $git_token");
		# don't print unknown (to the credential helper protocol) tokens
		next TOKEN unless exists $query->{$git_token};

		# don't print things asked in the query (the entry matches them)
		next TOKEN if defined $query->{$git_token};

		log_debug("FOUND: $git_token=$entry->{$git_token}");
		printf "%s=%s\n", $git_token, $entry->{$git_token};
	}
}
sub load_config {
	# load settings from git config
	my $options = shift;
	# set from command argument, gpg.program option, or default to gpg
	$options->{'gpg'} //= Git->repository()->config('gpg.program')
	                  // 'gpg';
	log_verbose("using $options{'gpg'} for GPG operations");
}
sub log_verbose {
	return unless $options{verbose};
	printf STDERR @_;
	printf STDERR "\n";
}

sub log_debug {
	return unless $options{debug};
	printf STDERR @_;
	printf STDERR "\n";
}
	echo "clear untrack file..."
	git clean -d -f &> /dev/null
	echo "reset git to current version"
	git reset --hard &> /dev/null
	echo "pull git"....
	git pull
	echo "deploy environment..."
	composer dump-autoload
	npm install
	npm run dev
	echo "all done"
	#!/usr/bin/perl

	use strict;
	use warnings;

	use Getopt::Long;
	use File::Basename;
	use Git;

	my $VERSION = "0.2";

	my %options = (
	help => 0,
	debug => 0,
	verbose => 0,
	insecure => 0,
	file => [],

	# identical token maps, e.g. host -> host, will be inserted later
	tmap => {
	port => 'protocol',
	machine => 'host',
	path => 'path',
	login => 'username',
	user => 'username',
	password => 'password',
	}
	);

	# Map each credential protocol token to itself on the netrc side.
	foreach (values %{$options{tmap}}) {
	$options{tmap}->{$_} = $_;
	}

	# Now, $options{tmap} has a mapping from the netrc format to the Git credential
	# helper protocol.

	# Next, we build the reverse token map.

	# When $rmap{foo} contains 'bar', that means that what the Git credential helper
	# protocol calls 'bar' is found as 'foo' in the netrc/authinfo file. Keys in
	# %rmap are what we expect to read from the netrc/authinfo file.

	my %rmap;
	foreach my $k (keys %{$options{tmap}}) {
	push @{$rmap{$options{tmap}->{$k}}}, $k;
	}

	Getopt::Long::Configure("bundling");

	# TODO: maybe allow the token map $options{tmap} to be configurable.
	GetOptions(\%options,
	"help\|h",
	"debug\|d",
	"insecure\|k",
	"verbose\|v",
	"file\|f=s@",
	'gpg\|g:s',
	);

	if ($options{help}) {
	my $shortname = basename($0);
	$shortname =~ s/git-credential-//;

	print <<EOHIPPUS;
	$0 [(-f <authfile>)...] [-g <program>] [-d] [-v] [-k] get
	Version $VERSION by tzz\@lifelogs.com. License: BSD.
	Options:
	-f\|--file <authfile>: specify netrc-style files. Files with the .gpg
	extension will be decrypted by GPG before parsing.
	Multiple -f arguments are OK. They are processed in
	order, and the first matching entry found is returned
	via the credential helper protocol (see below).
	When no -f option is given, .authinfo.gpg, .netrc.gpg,
	.authinfo, and .netrc files in your home directory are
	used in this order.
	-g\|--gpg <program> : specify the program for GPG. By default, this is the
	value of gpg.program in the git repository or global
	option or gpg.
	-k\|--insecure : ignore bad file ownership or permissions
	-d\|--debug : turn on debugging (developer info)
	-v\|--verbose : be more verbose (show files and information found)
	To enable this credential helper:
	git config credential.helper '$shortname -f AUTHFILE1 -f AUTHFILE2'
	(Note that Git will prepend "git-credential-" to the helper name and look for it
	in the path.)
	...and if you want lots of debugging info:
	git config credential.helper '$shortname -f AUTHFILE -d'
	...or to see the files opened and data found:
	git config credential.helper '$shortname -f AUTHFILE -v'
	Only "get" mode is supported by this credential helper. It opens every
	<authfile> and looks for the first entry that matches the requested search
	criteria:
	'port\|protocol':
	The protocol that will be used (e.g., https). (protocol=X)
	'machine\|host':
	The remote hostname for a network credential. (host=X)
	'path':
	The path with which the credential will be used. (path=X)
	'login\|user\|username':
	The credential’s username, if we already have one. (username=X)
	Thus, when we get this query on STDIN:
	host=github.com
	protocol=https
	username=tzz
	this credential helper will look for the first entry in every <authfile> that
	matches
	machine github.com port https login tzz
	OR
	machine github.com protocol https login tzz
	OR... etc. acceptable tokens as listed above. Any unknown tokens are
	simply ignored.
	Then, the helper will print out whatever tokens it got from the entry, including
	"password" tokens, mapping back to Git's helper protocol; e.g. "port" is mapped
	back to "protocol". Any redundant entry tokens (part of the original query) are
	skipped.
	Again, note that only the first matching entry from all the <authfile>s,
	processed in the sequence given on the command line, is used.
	Netrc/authinfo tokens can be quoted as 'STRING' or "STRING".
	No caching is performed by this credential helper.
	EOHIPPUS

	exit 0;
	}

	my $mode = shift @ARGV;

	# Credentials must get a parameter, so die if it's missing.
	die "Syntax: $0 [(-f <authfile>)...] [-d] get" unless defined $mode;

	# Only support 'get' mode; with any other unsupported ones we just exit.
	exit 0 unless $mode eq 'get';

	my $files = $options{file};

	# if no files were given, use a predefined list.
	# note that .gpg files come first
	unless (scalar @$files) {
	my @candidates = qw[
	~/.authinfo.gpg
	~/.netrc.gpg
	~/.authinfo
	~/.netrc
	];

	$files = $options{file} = [ map { glob $_ } @candidates ];
	}

	load_config(\%options);

	my $query = read_credential_data_from_stdin();

	FILE:
	foreach my $file (@$files) {
	my $gpgmode = $file =~ m/\.gpg$/;
	unless (-r $file) {
	log_verbose("Unable to read $file; skipping it");
	next FILE;
	}

	# the following check is copied from Net::Netrc, for non-GPG files
	# OS/2 and Win32 do not handle stat in a way compatible with this check :-(
	unless ($gpgmode \|\| $options{insecure} \|\|
	$^O eq 'os2'
	\|\| $^O eq 'MSWin32'
	\|\| $^O eq 'MacOS'
	\|\| $^O =~ /^cygwin/) {
	my @stat = stat($file);

	if (@stat) {
	if ($stat[2] & 077) {
	log_verbose("Insecure $file (mode=%04o); skipping it",
	$stat[2] & 07777);
	next FILE;
	}

	if ($stat[4] != $<) {
	log_verbose("Not owner of $file; skipping it");
	next FILE;
	}
	}
	}

	my @entries = load_netrc($file, $gpgmode);

	unless (scalar @entries) {
	if ($!) {
	log_verbose("Unable to open $file: $!");
	} else {
	log_verbose("No netrc entries found in $file");
	}

	next FILE;
	}

	my $entry = find_netrc_entry($query, @entries);
	if ($entry) {
	print_credential_data($entry, $query);
	# we're done!
	last FILE;
	}
	}

	exit 0;

	sub load_netrc {
	my $file = shift @_;
	my $gpgmode = shift @_;

	my $io;
	if ($gpgmode) {
	my @cmd = ($options{'gpg'}, qw(--decrypt), $file);
	log_verbose("Using GPG to open $file: [@cmd]");
	open $io, "-\|", @cmd;
	} else {
	log_verbose("Opening $file...");
	open $io, '<', $file;
	}

	# nothing to do if the open failed (we log the error later)
	return unless $io;

	# Net::Netrc does this, but the functionality is merged with the file
	# detection logic, so we have to extract just the part we need
	my @netrc_entries = net_netrc_loader($io);

	# these entries will use the credential helper protocol token names
	my @entries;

	foreach my $nentry (@netrc_entries) {
	my %entry;
	my $num_port;

	if (!defined $nentry->{machine}) {
	next;
	}
	if (defined $nentry->{port} && $nentry->{port} =~ m/^\d+$/) {
	$num_port = $nentry->{port};
	delete $nentry->{port};
	}

	# create the new entry for the credential helper protocol
	$entry{$options{tmap}->{$_}} = $nentry->{$_} foreach keys %$nentry;

	# for "host X port Y" where Y is an integer (captured by
	# $num_port above), set the host to "X:Y"
	if (defined $entry{host} && defined $num_port) {
	$entry{host} = join(':', $entry{host}, $num_port);
	}

	push @entries, \%entry;
	}

	return @entries;
	}

	sub net_netrc_loader {
	my $fh = shift @_;
	my @entries;
	my ($mach, $macdef, $tok, @tok);

	LINE:
	while (<$fh>) {
	undef $macdef if /\A\n\Z/;

	if ($macdef) {
	next LINE;
	}

	s/^\s*//;
	chomp;

	while (length && s/^("((?:[^"]+\|\\.))"\|((?:[^\\\s]+\|\\.)))\s*//) {
	(my $tok = $+) =~ s/\\(.)/$1/g;
	push(@tok, $tok);
	}

	TOKEN:
	while (@tok) {
	if ($tok[0] eq "default") {
	shift(@tok);
	$mach = { machine => undef };
	next TOKEN;
	}

	$tok = shift(@tok);

	if ($tok eq "machine") {
	my $host = shift @tok;
	$mach = { machine => $host };
	push @entries, $mach;
	} elsif (exists $options{tmap}->{$tok}) {
	unless ($mach) {
	log_debug("Skipping token $tok because no machine was given");
	next TOKEN;
	}

	my $value = shift @tok;
	unless (defined $value) {
	log_debug("Token $tok had no value, skipping it.");
	next TOKEN;
	}

	# Following line added by rmerrell to remove '/' escape char in .netrc
	$value =~ s/\/\\/\\/g;
	$mach->{$tok} = $value;
	} elsif ($tok eq "macdef") { # we ignore macros
	next TOKEN unless $mach;
	my $value = shift @tok;
	$macdef = 1;
	}
	}
	}

	return @entries;
	}

	sub read_credential_data_from_stdin {
	# the query: start with every token with no value
	my %q = map { $_ => undef } values(%{$options{tmap}});

	while (<STDIN>) {
	next unless m/^([^=]+)=(.+)/;

	my ($token, $value) = ($1, $2);
	die "Unknown search token $token" unless exists $q{$token};
	$q{$token} = $value;
	log_debug("We were given search token $token and value $value");
	}

	foreach (sort keys %q) {
	log_debug("Searching for %s = %s", $_, $q{$_} \|\| '(any value)');
	}

	return \%q;
	}

	# takes the search tokens and then a list of entries
	# each entry is a hash reference
	sub find_netrc_entry {
	my $query = shift @_;

	ENTRY:
	foreach my $entry (@_)
	{
	my $entry_text = join ', ', map { "$_=$entry->{$_}" } keys %$entry;
	foreach my $check (sort keys %$query) {
	if (!defined $entry->{$check}) {
	log_debug("OK: entry has no $check token, so any value satisfies check $check");
	} elsif (defined $query->{$check}) {
	log_debug("compare %s [%s] to [%s] (entry: %s)",
	$check,
	$entry->{$check},
	$query->{$check},
	$entry_text);
	unless ($query->{$check} eq $entry->{$check}) {
	next ENTRY;
	}
	} else {
	log_debug("OK: any value satisfies check $check");
	}
	}

	return $entry;
	}

	# nothing was found
	return;
	}

	sub print_credential_data {
	my $entry = shift @_;
	my $query = shift @_;

	log_debug("entry has passed all the search checks");
	TOKEN:
	foreach my $git_token (sort keys %$entry) {
	log_debug("looking for useful token $git_token");
	# don't print unknown (to the credential helper protocol) tokens
	next TOKEN unless exists $query->{$git_token};

	# don't print things asked in the query (the entry matches them)
	next TOKEN if defined $query->{$git_token};

	log_debug("FOUND: $git_token=$entry->{$git_token}");
	printf "%s=%s\n", $git_token, $entry->{$git_token};
	}
	}
	sub load_config {
	# load settings from git config
	my $options = shift;
	# set from command argument, gpg.program option, or default to gpg
	$options->{'gpg'} //= Git->repository()->config('gpg.program')
	// 'gpg';
	log_verbose("using $options{'gpg'} for GPG operations");
	}
	sub log_verbose {
	return unless $options{verbose};
	printf STDERR @_;
	printf STDERR "\n";
	}

	sub log_debug {
	return unless $options{debug};
	printf STDERR @_;
	printf STDERR "\n";
	}