syncwrap 1.5.2 → 2.0.0

data/lib/syncwrap/qpid.rb

@@ -1,251 +0,0 @@
-#--
-# Copyright (c) 2011-2013 David Kellum
-#
-# Licensed under the Apache License, Version 2.0 (the "License"); you
-# may not use this file except in compliance with the License.  You may
-# obtain a copy of the License at
-#
-#    http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-# implied.  See the License for the specific language governing
-# permissions and limitations under the License.
-#++
-
-require 'syncwrap/common'
-require 'syncwrap/distro'
-
-# Qpid AMQP broker provisioning. Currently this is RHEL/AmazonLinux
-# centric.
-module SyncWrap::Qpid
-  include SyncWrap::Common
-  include SyncWrap::Distro
-
-  attr_accessor :qpid_src_root
-
-  attr_accessor :qpid_version
-  attr_accessor :qpid_repo
-  attr_accessor :qpid_distro
-
-  attr_accessor :corosync_version
-  attr_accessor :corosync_repo
-
-  def initialize
-    super
-
-    @qpid_src_root = '/tmp/src'
-
-    @qpid_version = '0.18'
-    @qpid_repo = 'http://apache.osuosl.org/qpid'
-    @qpid_distro = 'amzn1'
-
-    @corosync_version = '1.4.4'
-    @corosync_repo = 'https://github.com/downloads/corosync/corosync'
-  end
-
-  def qpid_install
-    unless exist?( "/usr/local/sbin/qpidd" )
-      qpid_install!
-      qpid_install_init!
-    end
-    qpid_tools_install
-    rput( 'usr/local/etc/qpidd.conf', :user => 'root' )
-  end
-
-  def qpid_install_init!
-    unless exec_conditional { run "id qpidd >/dev/null" } == 0
-      sudo <<-SH
-        useradd -r qpidd
-        mkdir -p /var/local/qpidd
-        chown qpidd:qpidd /var/local/qpidd
-      SH
-    end
-
-    rput( 'etc/init.d/qpidd', :user => 'root' )
-
-    # Add to init.d
-    dist_install_init_service( 'qpidd' )
-  end
-
-  def qpid_tools_install
-    unless exist?( "/usr/bin/qpid-config" )
-      qpid_tools_install!
-    end
-  end
-
-  def qpid_install!
-    corosync_install!( :devel => true )
-    qpid_build
-  end
-
-  def qpid_tools_install!
-    dist_install( 'python-setuptools' )
-    qpid_src = "#{qpid_src_root}/qpid-#{qpid_version}"
-
-    run <<-SH
-      mkdir -p #{qpid_src_root}
-      rm -rf #{qpid_src}
-      cd #{qpid_src_root}
-      curl -sSL #{qpid_tools_tarball} | tar -zxf -
-    SH
-
-    sudo <<-SH
-      cd #{qpid_src}
-      easy_install ./python ./tools ./extras/qmf
-    SH
-  end
-
-  def qpid_build
-    qpid_install_build_deps
-    qpid_install_deps
-
-    qpid_src = "#{qpid_src_root}/qpidc-#{qpid_version}"
-
-    run <<-SH
-      mkdir -p #{qpid_src_root}
-      rm -rf #{qpid_src}
-      cd #{qpid_src_root}
-      curl -sSL #{qpid_src_tarball} | tar -zxf -
-      cd #{qpid_src}
-      ./configure > /dev/null
-      make > /dev/null
-    SH
-
-    sudo <<-SH
-      cd #{qpid_src}
-      make install > /dev/null
-    SH
-
-    run <<-SH
-      cd #{qpid_src}
-      make check > /dev/null
-    SH
-
-    sudo <<-SH
-      cd /usr/local
-      rm -f /tmp/qpidc-#{qpid_version}-1-#{qpid_distro}-x64.tar.gz
-      tar -zc \
-           --exclude games --exclude lib64/perl5 --exclude src \
-           --exclude share/man --exclude share/perl5 --exclude share/info \
-           --exclude share/applications \
-           -f /tmp/qpidc-#{qpid_version}-1-#{qpid_distro}-x64.tar.gz .
-    SH
-  end
-
-  def qpid_src_tarball
-    "#{qpid_repo}/#{qpid_version}/qpid-cpp-#{qpid_version}.tar.gz"
-  end
-
-  def qpid_tools_tarball
-    "#{qpid_repo}/#{qpid_version}/qpid-#{qpid_version}.tar.gz"
-  end
-
-  def qpid_install_build_deps
-    dist_install( %w[ gcc gcc-c++ make autogen autoconf
-                      help2man libtool pkgconfig rpm-build ] )
-  end
-
-  def qpid_install_deps
-    dist_install( %w[ nss-devel boost-devel libuuid-devel swig
-                      ruby-devel python-devel cyrus-sasl-devel ] )
-  end
-
-  def corosync_install( opts = {} )
-    unless exist?( "/usr/sbin/corosync" )
-      corosync_install!( opts )
-    end
-  end
-
-  def corosync_install!( opts = {} )
-    corosync_build
-    dist_install( "#{corosync_src}/x86_64/*.rpm", :succeed => true )
-  end
-
-  def corosync_build
-    qpid_install_build_deps
-    corosync_install_build_deps
-
-    run <<-SH
-      mkdir -p #{qpid_src_root}
-      rm -rf #{corosync_src}
-      cd #{qpid_src_root}
-      curl -sSL #{corosync_repo}/corosync-#{corosync_version}.tar.gz | tar -zxf -
-      cd #{corosync_src}
-      ./autogen.sh
-      ./configure > /dev/null
-      make rpm > /dev/null
-    SH
-
-  end
-
-  def corosync_packages( include_devel = false )
-    packs = [ "corosync-#{corosync_version}-1.#{qpid_distro}.x86_64.rpm",
-              "corosynclib-#{corosync_version}-1.#{qpid_distro}.x86_64.rpm" ]
-    packs <<  "corosynclib-devel-#{corosync_version}-1.#{qpid_distro}.x86_64.rpm" if include_devel
-    packs
-  end
-
-  def corosync_install_build_deps
-    dist_install( %w[ nss-devel libibverbs-devel librdmacm-devel ] )
-  end
-
-  def corosync_src
-    "#{qpid_src_root}/corosync-#{corosync_version}"
-  end
-
-  # Simplify qpid install by using pre-built binaries (for example,
-  # archived from the build steps above.)
-  module BinRepo
-    include SyncWrap::Qpid
-
-    attr_accessor :qpid_prebuild_repo
-
-    def initialize
-      super
-
-      @qpid_prebuild_repo = nil
-    end
-
-    def qpid_install
-      corosync_install
-      super
-    end
-
-    def qpid_install!
-      raise "qpid_prebuild_repo required, but not set" unless qpid_prebuild_repo
-
-      dist_install( %w[ boost cyrus-sasl ] )
-
-      sudo <<-SH
-        cd /usr/local
-        curl -sS #{qpid_prebuild_repo}/qpidc-#{qpid_version}-1-#{qpid_distro}-x64.tar.gz | tar -zxf -
-      SH
-    end
-
-    def corosync_install!( opts = {} )
-      raise "qpid_prebuild_repo required, but not set" unless qpid_prebuild_repo
-      packs = corosync_packages
-      curls = packs.map do |p|
-        "curl -sS -O #{qpid_prebuild_repo}/#{p}"
-      end
-
-      sudo <<-SH
-        rm -rf /tmp/rpm-drop
-        mkdir -p /tmp/rpm-drop
-        cd /tmp/rpm-drop
-        #{curls.join("\n")}
-      SH
-      dist_install( "/tmp/rpm-drop/*.rpm", :succeed => true )
-    end
-
-    # Where uploaded qpid-python-tools-M.N.tar.gz contains the
-    # ./python ./tools ./extras/qmf packages for easy_install.
-    def qpid_tools_tarball
-      "#{qpid_prebuild_repo}/qpid-python-tools-#{qpid_version}.tar.gz"
-    end
-
-  end
-
-end

data/lib/syncwrap/remote_task.rb

@@ -1,199 +0,0 @@
-#--
-# Copyright (c) 2011-2013 David Kellum
-#
-# Licensed under the Apache License, Version 2.0 (the "License"); you
-# may not use this file except in compliance with the License.  You may
-# obtain a copy of the License at
-#
-#    http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-# implied.  See the License for the specific language governing
-# permissions and limitations under the License.
-#++
-
-require 'rake/remote_task'
-
-require 'syncwrap/base'
-require 'syncwrap/common'
-
-# Implements common remoting methods in terms of rake/remote_task (and
-# thus Vlad compatible)
-module SyncWrap::RemoteTask
-  include SyncWrap::Common
-  include Rake::DSL
-
-  # Array of zero to many host_names (typically short) that were
-  # extracted from the HOSTS environment variable if set.
-  attr_reader :hosts
-
-  # A common domain name for all hosts, used to make host_long_name if
-  # specified (default: nil)
-  attr_accessor :common_domain
-
-  def initialize
-    @common_domain = nil
-    interpret_hosts_var
-    super
-
-    # Defaults:
-    set( :sudo_flags, %w[ -H ] )
-    set( :rsync_flags, %w[ -rlpcb -ii ] )
-
-    load_hosts_from_aws_instances if defined? aws_instances
-  end
-
-  # Implements SyncWrap::Common#run
-  def run( *args )
-    opts = args.last.is_a?( Hash ) && args.pop || {}
-
-    exit_multi = opts[ :error ].nil? || opts[ :error ] == :exit
-
-    args = cleanup_arg_lines( args, exit_multi )
-
-    remote_task_current.run( *args )
-  end
-
-  # Implements SyncWrap::Common#sudo
-  def sudo( *args )
-    opts = args.last.is_a?( Hash ) && args.pop || {}
-
-    flags = opts[ :flags ] || []
-    if opts[ :user ]
-      flags += [ '-u', opts[ :user ] ]
-    end
-
-    unless opts[ :shell ] == false
-      exit_multi = opts[ :error ].nil? || opts[ :error ] == :exit
-      cmd = cleanup_arg_lines( args, exit_multi )
-      cmd = shell_escape_cmd( cmd.join( ' ' ) )
-      cmd = "sh -c \"#{cmd}\""
-    else
-      cmd = cleanup_arg_lines( args, false )
-    end
-
-    remote_task_current.sudo( [ flags, cmd ] )
-  end
-
-  # Implements SyncWrap::Common#rsync
-  def rsync( *args )
-    remote_task_current.rsync( *args )
-  end
-
-  # Return the target host name of the currently executing RemoteTask.
-  # Raises a StandardError if executed out of that context.
-  def target_host
-    remote_task_current.target_host
-  end
-
-  # Return true if the current target_host or specified host is part
-  # of the specified role.
-  def host_in_role?( role, host = target_host )
-    role_hosts = Rake::RemoteTask.roles[ role ]
-    role_hosts && !!( role_hosts[ host ] )
-  end
-
-  # Implements Common#exec_conditional
-  def exec_conditional
-    yield
-    0
-  rescue Rake::CommandFailedError => e
-    e.status
-  end
-
-  # Remove extra whitespace from multi-line and single arguments
-  def cleanup_arg_lines( args, exit_error_on_multi )
-    args.flatten.compact.map do |arg|
-      alines = arg.split( $/ )
-      if alines.length > 1 && exit_error_on_multi
-        alines.unshift( "set -e" )
-      end
-      alines.map { |f| f.strip }.join( $/ )
-    end
-  end
-
-  def shell_escape_cmd( cmd )
-    cmd.gsub( /["$`\\]/ ) { |c| '\\' + c }
-  end
-
-  def remote_task( name, *args, &block )
-    Rake::RemoteTask.remote_task( name, *args, &block )
-  end
-
-  def set( *args )
-    Rake::RemoteTask.set( *args )
-  end
-
-  def interpret_hosts_var
-    hvar, ENV[ 'HOSTS' ] = ENV[ 'HOSTS' ], nil
-    @hosts = (hvar || '').strip.split( /\s+/ )
-    @host_pattern = if @hosts.empty?
-                      // #match all if none specified.
-                    else
-                      Regexp.new( '^((' + @hosts.join( ')|(' ) + '))$' )
-                    end
-  end
-
-  # Forward to Rake::RemoteTask.host using the host_long_name, but
-  # only if the specified host_name matches any host_pattern. The :all
-  # role is automatically included for all hosts.  Note this need not
-  # be manually provided int the Rakefile if aws_instances is provided
-  # instead.
-  def host( host_name, *roles )
-    if host_name =~ @host_pattern
-      Rake::RemoteTask.host( host_long_name( host_name ), :all, *roles )
-    end
-  end
-
-  # Define a RemoteTask host from an inst hash as defined by the AWS
-  # module. Override to change how instances are mapped to RemoteTask, host By
-  # default, using host_long_name( inst[:name] )
-  def host_from_instance( inst )
-    host( inst[:name], *inst[:roles] )
-  end
-
-  # Calls host_from_instance for all aws_instances.
-  def load_hosts_from_aws_instances
-    aws_instances.each do |inst|
-      host_from_instance( inst )
-    end
-  end
-
-  # Speculative override from AWS to automaticly set a host when added.
-  # Will fail if used without AWS module as super receiver.
-  def aws_instance_added( inst )
-    super
-    host_from_instance( inst )
-  end
-
-  # Forward to Rake::RemoteTask.role using the host_long_name, but only if
-  # the specified host_name matches any host_pattern.
-  def role( role_name, host_name = nil, args = {} )
-    if host_name =~ @host_pattern
-      Rake::RemoteTask.role( role_name, host_long_name( host_name ), args )
-    end
-  end
-
-  def remote_task_current
-    Thread.current[ :task ] or raise "Not running from a RemoteTask"
-  end
-
-  # Return a long name for the specified host_name (which may be
-  # short).  This implementation adds common_domain if
-  # specified. Otherwise host_name is returned unmodified.
-  def host_long_name( host_name )
-    if common_domain
-      "#{host_name}.#{common_domain}"
-    else
-      host_name
-    end
-  end
-
-  # Return a short name for the specified host_name (which may be long).
-  def host_short_name( host_name )
-    ( host_name =~ /^([a-z0-9\-]+)/ ) && $1
-  end
-
-end

data/lib/syncwrap/rhel.rb

@@ -1,67 +0,0 @@
-#--
-# Copyright (c) 2011-2013 David Kellum
-#
-# Licensed under the Apache License, Version 2.0 (the "License"); you
-# may not use this file except in compliance with the License.  You may
-# obtain a copy of the License at
-#
-#    http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-# implied.  See the License for the specific language governing
-# permissions and limitations under the License.
-#++
-
-require 'syncwrap/distro'
-
-# Customizations for RedHat Enterprise Linux and derivatives like
-# CentOS and Amazon Linux.  Specific distros/versions may further
-# override these.
-module SyncWrap::RHEL
-  include SyncWrap::Distro
-
-  def initialize
-    super
-
-    packages_map.merge!( 'emacs' => 'emacs-nox',
-                         'postgresql' => 'postgresql-server' )
-  end
-
-  # Generate command to install packages. The last argument is
-  # interpreted as a options if it is a Hash.
-  # === Options
-  # :succeed:: Always succeed (useful for local rpms which might
-  # already be installed.
-  def dist_install_s( *args )
-    if args.last.is_a?( Hash )
-      args = args.dup
-      opts = args.pop
-    else
-      opts = {}
-    end
-
-    args = dist_map_packages( args )
-
-    if opts[ :succeed ]
-      "yum install -q -y #{args.join ' '} || true"
-    else
-      "yum install -q -y #{args.join ' '}"
-    end
-  end
-
-  def dist_uninstall_s( *args )
-    args = dist_map_packages( args )
-    "yum remove -q -y #{args.join ' '}"
-  end
-
-  def dist_install_init_service_s( name )
-    "/sbin/chkconfig --add #{name}"
-  end
-
-  def dist_service_s( *args )
-    "/sbin/service #{args.join ' '}"
-  end
-
-end

data/lib/syncwrap/ubuntu.rb

@@ -1,78 +0,0 @@
-#--
-# Copyright (c) 2011-2013 David Kellum
-#
-# Licensed under the Apache License, Version 2.0 (the "License"); you
-# may not use this file except in compliance with the License.  You may
-# obtain a copy of the License at
-#
-#    http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-# implied.  See the License for the specific language governing
-# permissions and limitations under the License.
-#++
-
-require 'syncwrap/distro'
-require 'thread'
-
-# Customizations for Ubuntu and possibly other Debian/apt packaged
-# derivatives. Specific distros/versions may further specialize.
-module SyncWrap::Ubuntu
-  include SyncWrap::Distro
-
-  def initialize
-    @apt_update_state_lock = Mutex.new
-    @apt_update_state = {}
-
-    super
-
-    packages_map.merge!( 'apr'       => 'libapr1',
-                         'apr-devel' => 'libapr1-dev' )
-  end
-
-  # Generate the apt-get command to install packages. The first time
-  # this is applied to any given host, an "apt-get update" is issued
-  # as well. The last argument is interpreted as a options if it is a
-  # Hash.
-  # === Options
-  # :minimal:: Eqv to --no-install-recommends
-  def dist_install_s( *args )
-    args = args.dup
-    if args.last.is_a?( Hash )
-      opts = args.pop
-    else
-      opts = {}
-    end
-
-    commands = []
-
-    @apt_update_state_lock.synchronize do
-      unless @apt_update_state[ target_host ]
-        commands << "apt-get -yq update"
-        @apt_update_state[ target_host ] = true
-      end
-    end
-
-    args = dist_map_packages( args )
-    args.unshift "--no-install-recommends" if opts[ :minimal ]
-    commands << "apt-get -yq install #{args.join ' '}"
-
-    commands.join( "\n" )
-  end
-
-  def dist_uninstall_s( *args )
-    args = dist_map_packages( args )
-    "aptitude -yq purge #{args.join ' '}"
-  end
-
-  def dist_install_init_service_s( name )
-    "/usr/sbin/update-rc.d #{name} defaults"
-  end
-
-  def dist_service_s( *args )
-    "/usr/sbin/service #{args.join ' '}"
-  end
-
-end

data/lib/syncwrap/user_run.rb

@@ -1,102 +0,0 @@
-#--
-# Copyright (c) 2011-2013 David Kellum
-#
-# Licensed under the Apache License, Version 2.0 (the "License"); you
-# may not use this file except in compliance with the License.  You may
-# obtain a copy of the License at
-#
-#    http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-# implied.  See the License for the specific language governing
-# permissions and limitations under the License.
-#++
-
-require 'syncwrap/common'
-
-# Provisions for a (daemon) run user and var directory. Utilities for
-# working with the same.
-module SyncWrap::UserRun
-  include SyncWrap::Common
-
-  # A user for running deployed daemons, jobs (default: 'runr')
-  attr_accessor :user_run
-
-  # A group for running (default: 'runr')
-  attr_accessor :user_run_group
-
-  # Directory for persistent data, logs. (default: /var/local/runr)
-  attr_accessor :user_run_dir
-
-  def initialize
-    super
-
-    @user_run       = 'runr'
-    @user_run_group = 'runr'
-
-    @user_run_dir   = '/var/local/runr'
-  end
-
-  # Create and set owner/permission of run_dir, such that user_run may
-  # create new directories there.
-  def user_run_dir_setup
-    user_create
-    sudo <<-SH
-      mkdir -p #{user_run_dir}
-      chown #{user_run}:#{user_run_group} #{user_run_dir}
-      chmod 775 #{user_run_dir}
-    SH
-  end
-
-  # Create and set owner/permission of a named service directory under
-  # user_run_dir.
-  def user_run_service_dir_setup( sname, instance = nil )
-    sdir =  user_run_service_dir( sname, instance )
-
-    sudo <<-SH
-      mkdir -p #{sdir}
-      chown #{user_run}:#{user_run_group} #{sdir}
-      chmod 775 #{sdir}
-    SH
-  end
-
-  def user_run_service_dir( sname, instance = nil )
-    "#{user_run_dir}/" + [ sname, instance ].compact.join( '-' )
-  end
-
-  # As per SyncWrap::Common#rput with :user => user_run
-  def user_run_rput( *args )
-    opts = args.last.is_a?( Hash ) && args.pop || {}
-    opts[ :user ] = user_run
-    args.push( opts )
-    rput( *args )
-  end
-
-  # Chown to user_run where args may be flags and files/directories.
-  def user_run_chown( *args )
-    flags, paths = args.partition { |a| a =~ /^-/ }
-    sudo( 'chown', flags, "#{user_run}:#{user_run_group}", paths )
-  end
-
-  def user_exist?
-    exec_conditional { run "id #{user_run} >/dev/null" } == 0
-  end
-
-  def user_create
-    user_create! unless user_exist?
-  end
-
-  def user_create!
-    if user_run_group == user_run
-      sudo "useradd #{user_run}"
-    else
-      sudo <<-SH
-        groupadd #{user_run_group}
-        useradd -g #{user_run_group} #{user_run}
-      SH
-    end
-  end
-
-end