buzzware-buzzville 0.1.1 → 0.1.2

data/VERSION

@@ -1 +1 @@
-0.1.1
+0.1.2

data/buzzville.gemspec

@@ -5,7 +5,7 @@
 
 Gem::Specification.new do |s|
   s.name = %q{buzzville}
-  s.version = "0.1.1"
+  s.version = "0.1.2"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["buzzware"]
@@ -25,6 +25,8 @@ Gem::Specification.new do |s|
      "VERSION",
      "buzzville.gemspec",
      "lib/buzzville.rb",
+     "lib/buzzville/cap_utils.rb",
+     "lib/buzzville/ftp_extra.rb",
      "lib/buzzville/recipes.rb",
      "lib/buzzville/recipes/data.rb",
      "lib/buzzville/recipes/files.rb",

data/lib/buzzville/cap_utils.rb

@@ -0,0 +1,181 @@
+# use "extend CapUtils" inside a task to use this
+require 'buzzcore/misc_utils'
+require 'buzzcore/string_utils'
+require 'buzzcore/xml_utils'
+require 'buzzcore/shell_extras'
+require 'net/ssh'
+require 'net/sftp'
+
+module CapUtils
+
+	# upload the given local file to the remote server and set the given mode.
+	# 0644 is the default mode
+	#
+	# Unix file modes :
+	# 4: read
+	# 2: write
+	# 1: execute
+	# 0[owner][group][other]
+	def upload_file(aLocalFilePath,aRemoteFilePath,aMode = 0644)
+		puts "* uploading #{aLocalFilePath} to #{aRemoteFilePath}"
+		s = nil
+		File.open(aLocalFilePath, "rb") { |f| s = f.read }
+		put(s,aRemoteFilePath,:mode => aMode)
+	end
+	
+	def render_template_file(aTemplateFile,aXmlConfig,aOutputFile,aMoreConfig=nil)
+		template = MiscUtils.string_from_file(aTemplateFile)
+		values = XmlUtils.read_config_values(aXmlConfig)
+		values = values ? values.merge(aMoreConfig || {}) : aMoreConfig
+		result = StringUtils.render_template(template, values)
+		MiscUtils.string_to_file(result, aOutputFile)
+  end
+
+	def get_ip
+		run "ifconfig eth0 |grep \"inet addr\"" do |channel,stream,data|
+			return data.scan(/inet addr:([0-9.]+)/).flatten.pop
+		end
+	end
+
+	# check if file exists. Relies on remote ruby
+	def remote_file_exists?(aPath)
+		remote_ruby("puts File.exists?('#{aPath}').to_s")=="true\n"
+	end
+
+	def remote_ruby(aRubyString)
+		run 'ruby -e "'+aRubyString+'"' do |channel,stream,data|
+			return data
+		end
+	end
+
+	def sudo_run(aString)
+# 		as = fetch(:runner, "app")
+# 		via = fetch(:run_method, :sudo)
+# 		invoke_command(aString, :via => via, :as => as)
+# 		if aUseSudo
+# 			run "sudo "+aString
+# 		else
+			run aString
+# 		end
+	end
+
+	def upload_file_anywhere(aSourceFile,aDestHost,aDestUser,aDestPassword,aDestFile,aDestPort=22)
+		Net::SSH.start(aDestHost, aDestUser, {:port => aDestPort, :password => aDestPassword, :verbose =>Logger::DEBUG}) do |ssh|
+			File.open(aSourceFile, "rb") { |f| ssh.sftp.upload!(f, aDestFile) }
+		end
+	end
+
+	def branch_name_from_svn_url(aURL)
+		prot_domain = (aURL.scan(/[^:]+:\/\/[^\/]+\//)).first
+		without_domain = aURL[prot_domain.length..-1]
+		return 'trunk' if without_domain =~ /^trunk\//
+		return (without_domain.scan(/branches\/(.+?)(\/|$)/)).flatten.first
+	end
+	
+	# give block with |aText,aStream,aState| that returns response or nil
+	def run_respond(aCommand)
+		run(aCommand) do |ch,stream,text|
+			ch[:state] ||= { :channel => ch }
+			output = yield(text,stream,ch[:state])
+			ch.send_data(output) if output
+		end
+	end
+
+	# pass prompt to user, and return their response
+	def run_prompt(aCommand)
+		run_respond aCommand do |text,stream,state|
+			Capistrano::CLI.password_prompt(text)+"\n"
+		end
+	end
+	
+	def ensure_link(aTo,aFrom,aDir=nil,aUserGroup=nil)
+		cmd = []
+		cmd << "cd #{aDir}" if aDir
+		cmd << "#{sudo} rm -f #{aFrom}"
+		cmd << "#{sudo} ln -sf #{aTo} #{aFrom}"
+		cmd << "#{sudo} chown -h #{aUserGroup} #{aFrom}" if aUserGroup
+		run cmd.join(' && ')
+	end
+	
+
+	def file_exists?(path)
+		begin
+			run "ls #{path}"
+			return true
+		rescue Exception => e
+			return false
+		end
+	end
+	
+	# Used in deployment to maintain folder contents between deployments.
+	# Normally the shared path exists and will be linked into the release.
+	# If it doesn't exist and the release path does, it will be moved into the shared path
+	# aFolder eg. "vendor/extensions/design"
+	# aSharedFolder eg. "design" 
+	def preserve_folder(aReleaseFolder,aSharedFolder)	
+		aReleaseFolder = File.join(release_path,aReleaseFolder)
+		aSharedFolder = File.join(shared_path,aSharedFolder)
+		release_exists = file_exists?(aReleaseFolder)
+		shared_exists = file_exists?(aSharedFolder)
+		if shared_exists
+			run "rm -rf #{aReleaseFolder}" if release_exists
+		else
+			run "mv #{aReleaseFolder} #{aSharedFolder}" if release_exists
+		end
+		ensure_link("#{aSharedFolder}","#{aReleaseFolder}",nil,"#{user}:#{apache_user}")
+	end
+
+	def select_target_file(aFile)
+		ext = MiscUtils.file_extension(aFile,false)
+		no_ext = MiscUtils.file_no_extension(aFile,false)
+		dir = File.dirname(aFile)
+		run "#{sudo} mv -f #{no_ext}.#{target}.#{ext} #{aFile}"
+		run "#{sudo} rm -f #{no_ext}.*.#{ext}"
+	end
+	
+	def shell(aCommandline,&aBlock)
+		result = block_given? ? POpen4::shell(aCommandline,nil,nil,&aBlock) : POpen4::shell(aCommandline)
+		return result[:stdout]
+	end
+
+	def run_local(aString)
+		`#{aString}`
+	end
+
+
+	def run_for_all(aCommand,aPath,aFilesOrDirs,aPattern=nil,aInvertPattern=false,aSudo=true)
+		#run "#{sudo} find . -wholename '*/.svn' -prune -o -type d -print0 |xargs -0 #{sudo} chmod 750"
+		#sudo find . -type f -exec echo {} \;
+		cmd = []
+		cmd << "sudo" if aSudo
+		cmd << "find #{aPath}"
+		cmd << "-wholename '#{aPattern}'" if aPattern
+		cmd << "-prune -o" if aInvertPattern
+		cmd << case aFilesOrDirs.to_s[0,1]
+			when 'f' then '-type f'
+			when 'd' then '-type d'
+			else ''
+		end
+		cmd << "-exec"		
+		cmd << aCommand
+		cmd << '{} \;'		
+		cmd = cmd.join(' ')
+		run cmd
+	end
+	
+	# if aGroup is given, that will be the users only group
+	def adduser(aNewUser,aPassword,aGroup=nil)
+		run "#{sudo} adduser --gecos '' #{aGroup ? '--ingroup '+aGroup : ''} #{aNewUser}" do |ch, stream, out|
+			ch.send_data aPassword+"\n" if out =~ /UNIX password:/
+		end
+	end
+	
+	def add_user_to_group(aUser,aGroup)
+		run "#{sudo} usermod -a -G #{aGroup} #{aUser}"
+	end
+
+end
+
+class CapUtilsClass
+	self.extend CapUtils
+end

data/lib/buzzville/ftp_extra.rb

@@ -0,0 +1,188 @@
+require 'net/ftp'
+
+this_path = File.dirname(__FILE__)
+require this_path+'/misc_utils'
+
+String.class_eval do    
+  def bite!(aValue=$/,aString=self)
+    if aString[0,aValue.length] == aValue
+      aString[0,aValue.length] = ''
+      return aString
+    else
+      return aString
+    end
+  end
+
+  def bite(aValue=$/)
+    bite!(aValue,self.clone)
+  end  
+end
+
+
+module Net
+  class FTP
+		def FTP.with_connect(aHost,aUsername,aPassword,aDir=nil)
+			open(aHost,aUsername,aPassword) do |f|
+				f.passive = true
+				f.chdir(aDir) if aDir
+				yield f
+			end
+		end
+
+		def self.crack_file_line(aString)
+			values = aString.scan(/(.{10}).{28}(.{13})(.*)$/).flatten
+			{
+				:bits => values[0],
+				:date => values[1],
+				:name => values[2]
+			}
+		end
+
+		# BEGIN BUGFIXES
+
+    #
+    # Returns the size of the given (remote) filename.
+    #
+    def size(filename)
+      voidcmd("TYPE I")
+      resp = sendcmd("SIZE " + filename)
+			code = resp[0, 3]
+      if code != "213" && code != "220"
+	raise FTPReplyError, resp
+      end
+      return resp[3..-1].strip.to_i
+    end
+
+		# END BUGFIXES
+
+		def subdirs(aPath)
+			list.delete_if {|line| line[0,1]=='d'}
+			return list
+		end
+
+		def files(aPath)
+			list.delete_if {|line| line[0,1]!='d'}
+			return list
+		end
+
+		def expand_dir(aPath,aBase=nil)
+			return aPath if aPath=='/'
+			return MiscUtils::path_relative?(aPath) ? File.expand_path(aPath,aBase || pwd()) : File.expand_path(aPath)
+		end
+
+		def dir_exists?(aPath)
+			aPath = expand_dir(aPath)
+			return true if aPath=='/'
+			dirname = File.basename(aPath)
+			parent = MiscUtils.path_parent(aPath)
+			dirname!='' && nlst(parent).include?(dirname)
+		end
+
+		def file_exists?(aPath)
+			aPath = expand_dir(aPath)
+			filename = File.basename(aPath)
+			parent = File.dirname(aPath)
+			filename!='' && nlst(parent).include?(filename)
+		end
+
+		def filelist_recurse(aPath=nil,aResult=nil,&block)
+			#puts "filelist_recurse: #{aPath.to_s}  #{aResult.inspect}"
+			orig_dir = !aResult ? pwd : nil	# assigned if called at top with aResult=nil
+			aResult ||= []
+			aPath ||= ''
+			chdir(aPath)
+			list('*').each do |f| 
+				is_dir = f[0,1]=='d'
+				details = FTP::crack_file_line(f)
+				full = File.join(aPath,details[:name])
+				if !block_given? || yield(full)
+					if is_dir
+						filelist_recurse(full,aResult)
+					else
+						aResult << full
+					end
+				end
+			end
+			chdir(orig_dir) if orig_dir
+			return aResult
+		end
+
+		def get_files(aRemoteDir,aLocalDir,aFiles,aOptions=nil)
+			aOptions = {:overwrite => true}.merge(aOptions || {})
+			aFiles.each do |r|
+				relative = r.bite(MiscUtils::append_slash(aRemoteDir))
+				d = File.join(aLocalDir,relative)
+				puts "getting #{relative}"
+				getbinaryfile(r, d) unless !aOptions[:overwrite] && File.exists?(d)
+			end
+		end
+
+		def get_dir(aRemoteDir,aLocalDir,aOptions=nil,&block)
+			remote_files = block_given? ? filelist_recurse(aRemoteDir,nil,&block) : filelist_recurse(aRemoteDir)
+			get_files(aRemoteDir,aLocalDir,remote_files,aOptions)
+		end
+
+		def highest_existing(aPath)
+			sep = MiscUtils::sniff_seperator(aPath)
+			path = MiscUtils::path_parts(File.expand_path(aPath)) if aPath.is_a?(String)
+			# now assume path is an Array
+			depth = path.length-1
+			depth.downto(0) do |i|	# from full path up to root
+				curr = (path[0]=='' && i==0) ? '/' : path[0..i].join(sep)
+				return curr if dir_exists?(curr)
+			end
+			return sep	# root
+		end
+
+		def ensure_dir(aPath,aThorough=false)
+			if !aThorough
+				mkdir(aPath) unless dir_exists?(aPath)
+			else
+				return if dir_exists?(aPath)
+				path = expand_dir(aPath)
+				hi_existing = highest_existing(path)
+				# path to create under hi_existing
+				to_create = MiscUtils::path_debase(path,hi_existing)
+				parts = MiscUtils::path_parts(to_create)
+				curr_path = hi_existing
+				
+				parts.each do |part|
+					curr_path = File.join(curr_path,part)
+					mkdir(curr_path)
+				end
+			end
+		end
+
+		def put_files(aLocalDir,aRemoteDir,aFiles,aOptions=nil)
+			aOptions = {:overwrite => true}.merge(aOptions || {})
+
+			# convert all files to relative to aLocalDir
+			aFiles = aFiles.map { |f| f.bite(MiscUtils::append_slash(aLocalDir)) }.sort
+			
+			filelist = nil
+			this_dir = last_dir = nil
+			aFiles.each do |r|
+				d = File.expand_path(r,aRemoteDir)
+				this_dir = File.dirname(d)
+				if this_dir!=last_dir
+					ensure_dir(this_dir,true)
+					filelist = files(this_dir) - ['.','..','.svn']
+				end
+				if aOptions[:overwrite] || !filelist.member?(File.basename(r))
+					puts "Putting #{r}"
+					putbinaryfile(File.expand_path(r,aLocalDir), d)
+				else
+					puts "Skipping #{relative}"
+				end
+				last_dir = this_dir
+			end
+		end
+
+		def put_dir(aLocalDir,aRemoteDir,&block)
+			local_files = block_given? ? MiscUtils::recursive_file_list(aLocalDir,true,&block) : MiscUtils::recursive_file_list(aLocalDir) 
+			put_files(aLocalDir,aRemoteDir,local_files)
+		end
+
+	end
+end
+

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: buzzware-buzzville
 version: !ruby/object:Gem::Version 
-  version: 0.1.1
+  version: 0.1.2
 platform: ruby
 authors: 
 - buzzware
@@ -50,6 +50,8 @@ files:
 - VERSION
 - buzzville.gemspec
 - lib/buzzville.rb
+- lib/buzzville/cap_utils.rb
+- lib/buzzville/ftp_extra.rb
 - lib/buzzville/recipes.rb
 - lib/buzzville/recipes/data.rb
 - lib/buzzville/recipes/files.rb
@@ -59,7 +61,6 @@ files:
 - test/test_helper.rb
 has_rdoc: true
 homepage: http://github.com/buzzware/buzzville
-licenses: 
 post_install_message: 
 rdoc_options: 
 - --charset=UTF-8
@@ -80,7 +81,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: buzzware
-rubygems_version: 1.3.5
+rubygems_version: 1.2.0
 signing_key: 
 specification_version: 2
 summary: Capistrano recipes and ruby code relating to deployment