tpkg 2.3.3 → 2.3.4

data/bin/gem2tpkg

@@ -19,7 +19,7 @@ require 'facter'
 
 # We don't want to just use the first gem command in the user's PATH by
 # default, as that may not be a tpkg gem.  I.e. /usr/bin/gem on Mac OS X.
-DEFAULT_GEM_COMMAND = "#{Tpkg::DEFAULT_BASE}/ruby-1.8/bin/gem"
+DEFAULT_GEM_COMMAND = "#{Tpkg::DEFAULT_BASE}/bin/gem"
 
 # Ruby 1.8.7 and later have Dir.mktmpdir, but we support ruby 1.8.5 for
 # RHEL/CentOS 5.  So this is a basic substitute.
@@ -423,7 +423,7 @@ def package(gem)
     # If the gemspec lists any extensions then the package has native
     # code and needs to be flagged as specific to the OS and architecture
     if gemspec.extensions && !gemspec.extensions.empty?
-      os = Tpkg::get_os
+      os = tpkg.os.os
       if os =~ /RedHat-(.*)/
         os = os + ", CentOS-#{$1}"
       elsif os =~ /CentOS-(.*)/

data/bin/tpkg

@@ -23,6 +23,7 @@ require 'tpkg'
 @prompt = true
 @quiet = false
 @sudo = nil
+@sudo_option = nil
 @force = false
 @deploy = false
 @deploy_params = ARGV   # hold parameters for how to invoke tpkg on the machines we're deploying to
@@ -65,7 +66,7 @@ def parse_config_files
   
   # FIXME: Move config file parsing to tpkg.rb
   # https://github.com/tpkg/client/issues/22
-  fsroot = @tpkg_options[:file_system_root] ? @tpkg_options[:file_system_root] : ''
+  fsroot = @tpkg_options[:file_system_root] || ''
   settings = {:sources => []}
   [File.join(fsroot, Tpkg::DEFAULT_CONFIGDIR, 'tpkg.conf'),
    File.join(fsroot, ENV['HOME'], ".tpkg.conf")].each do |configfile|
@@ -168,7 +169,7 @@ opts.on('--groups', '-g', '=GROUP', Array, 'Group of server on which to apply ac
   # abbreviation.  I.e. if the option is --servers and the user specified
   # --serv (which OptionParser will accept as long as it is unambiguous) this
   # won't detect and remove it.
-  @deploy_params = @deploy_params - ['--groups', '-g', @groups.join(","), "--servers=#{@groups.join(',')}"]
+  @deploy_params = @deploy_params - ['--groups', '-g', @groups.join(","), "--groups=#{@groups.join(',')}"]
 end
 opts.on('--ua', 'Upgrade all packages') do |opt|
   @rerun_with_sudo = true
@@ -363,7 +364,7 @@ opts.on('--quiet', 'Reduce informative but non-essential output') do |opt|
   @quiet = opt
 end
 opts.on('--no-sudo', 'No calls to sudo for operations that might need root') do |opt|
-  @sudo = opt
+  @sudo_option = opt
 end
 opts.on('--lock-force', 'Force the removal of an existing lockfile') do |opt|
   @tpkg_options[:lockforce] = opt
@@ -449,7 +450,7 @@ if @groups
     end
     servers = []
     @groups.each do |group|
-      IO.popen(settings[:host_group_script]) do |pipe|
+      IO.popen(settings[:host_group_script]<<" "<<group.chomp) do |pipe|
         pipe.each_line do |line|
           servers << line.chomp
         end
@@ -510,14 +511,17 @@ end
 # order:
 # - command line option
 # - config file
-# - Tpkg.sudo_default? method defined in tpkg.rb
+# - Default based on OS (Tpkg::OS#sudo_default?)
 case
-when !@sudo.nil?
-  @tpkg_options[:sudo] = @sudo
+when !@sudo_option.nil?
+  @sudo = @sudo_option
 when settings.has_key?(:sudo)
-  @sudo = @tpkg_options[:sudo] = settings[:sudo]
+  @sudo = settings[:sudo]
 else
-  @sudo = @tpkg_options[:sudo] = Tpkg.sudo_default?
+  # This bit of horribleness will be better when option parsing gets moved
+  # into tpkg.rb
+  os = Tpkg::OS.create
+  @sudo = os.sudo_default?
 end
 @tpkg_options[:force] = @force
 
@@ -529,7 +533,7 @@ if !@sudo
     # modified by other users who properly run --no-sudo as a regular user.
     raise "--no-sudo cannot be used as 'root' user or via sudo"
   end
-  fsroot = @tpkg_options[:file_system_root] ? @tpkg_options[:file_system_root] : ''
+  fsroot = @tpkg_options[:file_system_root] || ''
   base = File.join(fsroot, @tpkg_options[:base])
   if File.exist?(base)
     baseuid = File.stat(base).uid
@@ -961,7 +965,7 @@ when :query_requires
       dependencies.each do | requiree, deps |
         next if deps.nil?
         deps.each do | dep | 
-          if Tpkg::package_meets_requirement?(pkg, dep)
+          if tpkg.package_meets_requirement?(pkg, dep)
             pkgfilename = pkg[:metadata][:filename]
             if !requirees[pkgfilename]
               requirees[pkgfilename] = []
@@ -1152,8 +1156,9 @@ when :query_tpkg_metadata_available
     FileUtils.rm_rf(downloaddir)
   end
 when :query_env
-  puts "Operating System: #{Tpkg::get_os}"
-  puts "Architecture: #{Tpkg::get_arch}"
+  tpkg = Tpkg.new(@tpkg_options)
+  puts "Operating System: #{tpkg.os.os}"
+  puts "Architecture: #{tpkg.os.arch}"
   puts "Tar: #{Tpkg::find_tar}"
 when :query_conf
   # This is somewhat arbitrarily limited to the options read from the

data/bin/tpkg_uploader

@@ -0,0 +1,132 @@
+#!/usr/bin/ruby
+##############################################################################
+# tpkg package management system
+# License: MIT (http://www.opensource.org/licenses/mit-license.php)
+##############################################################################
+
+# Simple script for uploading packages to a tpkg server.
+# Requires curl in order to work
+
+require 'ping'
+require 'tempfile'  
+require 'optparse'
+require 'etc'
+require 'uri'
+require 'cgi'
+
+##########################################################################
+# Set these variables to the appropriate values that suit your environment
+authentication_url = "http://localhost:3000/login"
+tpkg_upload_url = "http://localhost:3000/uploads/create"
+proxy_server = "proxy.local:8080"
+##########################################################################
+
+username = Etc.getlogin
+password = nil
+files_to_upload = nil
+proxy = ""
+cookie_file = nil
+opts = OptionParser.new
+opts.banner = 'Usage: tpkg [options]'
+opts.on('-u', '--username USERNAME', 'Your username') do |opt|
+  username = opt
+end
+opts.on('-p', '--password PASSWORD', 'Your password') do |opt|
+  password = opt
+end
+opts.on('-f', '--file FILES', Array, 'Comma-separated list of files you want to upload') do |opt|
+  files_to_upload = opt
+end
+opts.on('--source_dir DIR', 'Directory containing *.tpkg files that you want to upload') do |opt|
+  if !File.directory?(opt)
+    raise "#{opt} is not a directory"
+  else
+    files_to_upload = Dir.glob(File.join(opt, '*.tpkg'))
+  end
+end
+opts.on('-x', '--proxy PROXY', 'Proxy to connect to tpkg server (if needed)') do |opt|
+  proxy = "--proxy #{opt}"
+end
+opts.on('--server SERVER', 'Where to upload the package to') do |opt|
+  tpkg_upload_url = "http://#{opt}/uploads/create"
+end
+opts.on('--cookie FILE', 'Path where cookie is stored') do |opt|
+  cookie_file = opt
+end
+
+opts.on_tail("-h", "--help", "Show this message") do
+  puts opts
+  exit
+end
+
+opts.parse(ARGV)
+
+# Authenticate against tpkg server either using existing cookie file (saved from curl)
+# or username/password
+# To save cookie file, use the following curl command
+#    curl https://myserver/login --data 'login=username&password=password' -k -c path_to_save_the_cookie
+
+if cookie_file
+  if !File.exists?(cookie_file)
+    puts "Cookie file doesn't exist" 
+    exit
+  end
+else
+  # ask for username and password if user doesn't specify it
+  if username.nil?
+    print "Enter your username: "
+    username = STDIN.gets.chomp
+  end
+
+  if password.nil?
+    begin
+      system 'stty -echo'
+      print "Enter your password: "
+      password = STDIN.gets.chomp
+    ensure
+      system 'stty echo; echo ""'
+    end
+  end
+
+  curl_config=Tempfile.new("curl_config")
+  cookie_file=Tempfile.new("cookie").path
+
+  # See if we can talk to the authentication server. If not, we might need to use a proxy
+  if (proxy.nil? || proxy.empty?) && !Ping.pingecho(URI.parse(authentication_url).host, 2, URI.parse(authentication_url).port)
+    proxy = "--proxy #{proxy_server}"
+    puts "Can't connect to authentication server directly. Trying to connect via #{proxy}."
+  end
+
+  # We need to authenticate against the server first in order to get a cookie
+  # To prevent username and password showing up when we call
+  # curl, we will tell curl to look it up from a config file
+  config="data = \"login=#{CGI.escape(username)}&password=#{CGI.escape(password)}\""
+  File.open(curl_config.path, 'w') {|f| f.write(config) }
+  result = `curl #{authentication_url} -s -L -K #{curl_config.path} -k -c #{cookie_file} #{proxy}`
+  if result =~ /failed/
+    puts "Failed to authenticate."
+    exit
+  end
+end
+
+# Get file to upload
+if files_to_upload.nil?
+  print "Specify the file you want to upload: "
+  files_to_upload = [STDIN.gets.chomp]
+end
+
+
+# Do the actual upload
+files_to_upload.each do | file |
+  # check if file exists
+  if File.file?(file)
+    file = File.expand_path(file)
+  else
+    puts "File doesn't exist"
+    exit
+  end
+
+  puts "Uploading #{file} to #{URI.parse(tpkg_upload_url).host}"
+  out=`curl -b #{cookie_file} -F upload[upload]=@'#{file}' #{tpkg_upload_url} #{proxy}`
+  puts out
+end

data/ca.pem

@@ -0,0 +1 @@
+# Add your SSL certificate authority's cert(s) to this file

data/control

@@ -0,0 +1,7 @@
+Package: tpkg
+Version: %VER%-1
+Maintainer: tpkg-users@lists.sourceforge.net
+Architecture: all
+Depends: ruby-interpreter, facter, lsb-release, lsb-base
+Description: tpkg client
+

data/depend

@@ -0,0 +1,3 @@
+P CSWruby
+P CSWfacter
+

data/externals-etch/authorized_keys

@@ -0,0 +1,40 @@
+#!/bin/sh
+
+set -e
+
+pkgfile=$1
+operation=$2
+
+# Grab the data passed to us on stdin
+datafile=`mktemp`
+cat > $datafile
+# We expect just one line of data containing the home directory path
+homedir=`head -1 $datafile`
+# Make sure we got some sort of string for the home directory
+test -n "$homedir"
+
+requestfile=/var/etch/requests/$homedir/.ssh/authorized_keys/$pkgfile
+
+case "$operation" in
+'install')
+	mkdir -p `dirname "$requestfile"`
+	tmpfile=`mktemp "$requestfile.XXXXXX"` || exit 1
+	echo "<request>" > $tmpfile
+	# Dump in the data we captured above
+	cat $datafile >> $tmpfile
+	echo "</request>" >> $tmpfile
+	chmod 644 "$tmpfile"
+	;;
+'remove')
+	rm -f "$requestfile".*
+	;;
+*)
+	echo "$0: Invalid arguments"
+	exit 1
+	;;
+esac
+
+# There's no guarantee that the user has keys in etch, and etch will throw an
+# error if you ask it to generate a file that it doesn't know about.
+#/usr/sbin/etch $homedir/.ssh/authorized_keys
+

data/externals-etch/group

@@ -0,0 +1,9 @@
+#!/bin/sh
+
+# This is a no-op in our environment as we always add all available groups to
+# all systems.
+
+# However, we need to take all the data fed to us so as not to trigger a
+# SIGPIPE in the caller.
+cat > /dev/null
+

data/externals-etch/iptables

@@ -0,0 +1,38 @@
+#!/bin/sh
+
+set -e
+
+pkgfile=$1
+operation=$2
+
+# /etc/sysconfig/iptables for Red Hat
+# /var/lib/iptables/active for Debian
+requestfiles="/var/etch/requests/etc/sysconfig/iptables/$pkgfile /var/etch/requests/var/lib/iptables/active/$pkgfile"
+
+case "$operation" in
+'install')
+	for requestfile in $requestfiles
+	do
+		mkdir -p `dirname "$requestfile"`
+		tmpfile=`mktemp "$requestfile.XXXXXX"` || exit 1
+		echo "<request>" > $tmpfile
+		# Dump in the data passed to us on stdin
+		cat >> $tmpfile
+		echo "</request>" >> $tmpfile
+		chmod 644 "$tmpfile"
+	done
+	;;
+'remove')
+	for requestfile in $requestfiles
+	do
+		rm -f "$requestfile".*
+	done
+	;;
+*)
+	echo "$0: Invalid arguments"
+	exit 1
+	;;
+esac
+
+/usr/sbin/etch /etc/sysconfig/iptables /var/lib/iptables/active
+

data/externals-etch/limits

@@ -0,0 +1,30 @@
+#!/bin/sh
+
+set -e
+
+pkgfile=$1
+operation=$2
+
+requestfile=/var/etch/requests/etc/security/limits.conf/$pkgfile
+
+case "$operation" in
+'install')
+	mkdir -p `dirname "$requestfile"`
+	tmpfile=`mktemp "$requestfile.XXXXXX"` || exit 1
+	echo "<request>" > $tmpfile
+	# Dump in the data passed to us on stdin
+	cat >> $tmpfile
+	echo "</request>" >> $tmpfile
+	chmod 644 "$tmpfile"
+	;;
+'remove')
+	rm -f "$requestfile".*
+	;;
+*)
+	echo "$0: Invalid arguments"
+	exit 1
+	;;
+esac
+
+/usr/sbin/etch /etc/security/limits.conf
+

data/externals-etch/nfs

@@ -0,0 +1,30 @@
+#!/bin/sh
+
+set -e
+
+pkgfile=$1
+operation=$2
+
+requestfile=/var/etch/requests/etc/auto.auto/$pkgfile
+
+case "$operation" in
+'install')
+	mkdir -p `dirname "$requestfile"`
+	tmpfile=`mktemp "$requestfile.XXXXXX"`
+	echo "<request>" > $tmpfile
+	# Dump in the data passed to us on stdin
+	cat >> $tmpfile
+	echo "</request>" >> $tmpfile
+	chmod 644 "$tmpfile"
+	;;
+'remove')
+	rm -f "$requestfile".*
+	;;
+*)
+	echo "$0: Invalid arguments"
+	exit 1
+	;;
+esac
+
+/usr/sbin/etch /etc/auto.auto
+

data/externals-etch/sudo

@@ -0,0 +1,30 @@
+#!/bin/sh
+
+set -e
+
+pkgfile=$1
+operation=$2
+
+requestfile=/var/etch/requests/etc/sudoers/$pkgfile
+
+case "$operation" in
+'install')
+	mkdir -p `dirname "$requestfile"`
+	tmpfile=`mktemp "$requestfile.XXXXXX"` || exit 1
+	echo "<request>" > $tmpfile
+	# Dump in the data passed to us on stdin
+	cat >> $tmpfile
+	echo "</request>" >> $tmpfile
+	chmod 644 "$tmpfile"
+	;;
+'remove')
+	rm -f "$requestfile".*
+	;;
+*)
+	echo "$0: Invalid arguments"
+	exit 1
+	;;
+esac
+
+/usr/sbin/etch /etc/sudoers
+

data/externals-etch/supplemental_groups

@@ -0,0 +1,8 @@
+#!/bin/sh
+
+# This is a no-op in our environment as we always add all available groups to
+# all systems.
+
+# However, we need to take all the data fed to us so as not to trigger a
+# SIGPIPE in the caller.
+cat > /dev/null