deac/middleman-deploy
1
0
Fork 0
Code Issues Pull requests Releases Wiki Activity

Refactoring

Browse source 
- Create a class per method
- Create a class per git strategy
- Extract USAGE into a file
- Refactor git and ftp/sftp methods
This commit is contained in:
Cecile Veneziani 2014-01-16 15:25:40 +01:00
parent 064b17add2
commit 11860dd930
12 changed files with 483 additions and 263 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

55
USAGE Normal file
View file

@ -0,0 +1,55 @@
You should follow one of the four examples below to setup the deploy
extension in config.rb.
# To deploy the build directory to a remote host via rsync:
activate :deploy do |deploy|
deploy.method = :rsync
# host and path *must* be set
deploy.host = "www.example.com"
deploy.path = "/srv/www/site"
# user is optional (no default)
deploy.user = "tvaughan"
# port is optional (default is 22)
deploy.port = 5309
# clean is optional (default is false)
deploy.clean = true
# flags is optional (default is -avze)
deploy.flags = "-rltgoDvzO --no-p --del -e"
end
# To deploy to a remote branch via git (e.g. gh-pages on github):
activate :deploy do |deploy|
deploy.method = :git
# remote is optional (default is "origin")
# run `git remote -v` to see a list of possible remotes
deploy.remote = "some-other-remote-name"
# branch is optional (default is "gh-pages")
# run `git branch -a` to see a list of possible branches
deploy.branch = "some-other-branch-name"
# strategy is optional (default is :force_push)
deploy.strategy = :submodule
end
# To deploy the build directory to a remote host via ftp:
activate :deploy do |deploy|
deploy.method = :ftp
# host, user, passwword and path *must* be set
deploy.host = "ftp.example.com"
deploy.path = "/srv/www/site"
deploy.user = "tvaughan"
deploy.password = "secret"
end
# To deploy the build directory to a remote host via sftp:
activate :deploy do |deploy|
deploy.method = :sftp
# host, user, passwword and path *must* be set
deploy.host = "sftp.example.com"
deploy.path = "/srv/www/site"
# user is optional (no default)
deploy.user = "tvaughan"
# password is optional (no default)
deploy.password = "secret"
end

295
lib/middleman-deploy/commands.rb
View file

@ -1,6 +1,8 @@
require "middleman-core/cli"
require "middleman-deploy/extension"
require "middleman-deploy/methods"
require "middleman-deploy/strategies"
require "middleman-deploy/pkg-info"
module Middleman
@ -21,304 +23,71 @@ module Middleman
desc "deploy [options]", Middleman::Deploy::TAGLINE
method_option "build_before",
:type => :boolean,
:aliases => "-b",
:desc => "Run `middleman build` before the deploy step"
:type => :boolean,
:aliases => "-b",
:desc => "Run `middleman build` before the deploy step"
def deploy
if options.has_key? "build_before"
build_before = options.build_before
else
build_before = self.deploy_options.build_before
end
if build_before
# http://forum.middlemanapp.com/t/problem-with-the-build-task-in-an-extension
run("middleman build") || exit(1)
end
send("deploy_#{self.deploy_options.method}")
build_before(options)
process
end
protected
def print_usage_and_die(message)
raise Error, "ERROR: " + message + "\n" + <<EOF
def build_before(options={})
build_enabled = options.fetch('build_before', self.deploy_options.build_before)
You should follow one of the four examples below to setup the deploy
extension in config.rb.
# To deploy the build directory to a remote host via rsync:
activate :deploy do |deploy|
deploy.method = :rsync
# host and path *must* be set
deploy.host = "www.example.com"
deploy.path = "/srv/www/site"
# user is optional (no default)
deploy.user = "tvaughan"
# port is optional (default is 22)
deploy.port = 5309
# clean is optional (default is false)
deploy.clean = true
# flags is optional (default is -avze)
deploy.flags = "-rltgoDvzO --no-p --del -e"
end
# To deploy to a remote branch via git (e.g. gh-pages on github):
activate :deploy do |deploy|
deploy.method = :git
# remote is optional (default is "origin")
# run `git remote -v` to see a list of possible remotes
deploy.remote = "some-other-remote-name"
# branch is optional (default is "gh-pages")
# run `git branch -a` to see a list of possible branches
deploy.branch = "some-other-branch-name"
# strategy is optional (default is :force_push)
deploy.strategy = :submodule
end
# To deploy the build directory to a remote host via ftp:
activate :deploy do |deploy|
deploy.method = :ftp
# host, user, passwword and path *must* be set
deploy.host = "ftp.example.com"
deploy.path = "/srv/www/site"
deploy.user = "tvaughan"
deploy.password = "secret"
end
# To deploy the build directory to a remote host via sftp:
activate :deploy do |deploy|
deploy.method = :sftp
# host, user, passwword and path *must* be set
deploy.host = "sftp.example.com"
deploy.path = "/srv/www/site"
# user is optional (no default)
deploy.user = "tvaughan"
# password is optional (no default)
deploy.password = "secret"
end
EOF
if build_enabled
# http://forum.middlemanapp.com/t/problem-with-the-build-task-in-an-extension
run('middleman build') || exit(1)
end
end
def inst
::Middleman::Application.server.inst
def print_usage_and_die(message)
usage_path = File.join(File.dirname(__FILE__), '..', '..', 'USAGE')
usage_message = File.read(usage_path)
raise Error, "ERROR: #{message}\n#{usage_message}"
end
def process
server_instance = ::Middleman::Application.server.inst
camelized_method = self.deploy_options.method.to_s.split('_').map { |word| word.capitalize}.join
method_class_name = "Middleman::Deploy::Methods::#{camelized_method}"
method_instance = method_class_name.constantize.new(server_instance, self.deploy_options)
method_instance.process
end
def deploy_options
options = nil
begin
options = inst.options
options = ::Middleman::Application.server.inst.options
rescue NoMethodError
print_usage_and_die "You need to activate the deploy extension in config.rb."
end
if (!options.method)
unless options.method
print_usage_and_die "The deploy extension requires you to set a method."
end
case options.method
when :rsync, :sftp
if (!options.host || !options.path)
unless options.host && options.path
print_usage_and_die "The #{options.method} method requires host and path to be set."
end
when :ftp
if (!options.host || !options.user || !options.password || !options.path)
unless options.host && options.user && options.password && options.path
print_usage_and_die "The ftp deploy method requires host, path, user, and password to be set."
end
end
options
end
def deploy_rsync
host = self.deploy_options.host
port = self.deploy_options.port
path = self.deploy_options.path
# Append "@" to user if provided.
user = self.deploy_options.user
user = "#{user}@" if user && !user.empty?
dest_url = "#{user}#{host}:#{path}"
puts "## Deploying via rsync to #{dest_url} port=#{port}"
flags = !self.deploy_options.flags ? '-avze' : self.deploy_options.flags
command = "rsync " + flags + " '" + "ssh -p #{port}" + "' #{self.inst.build_dir}/ #{dest_url}"
if self.deploy_options.clean
command += " --delete"
end
run command
end
def deploy_git
remote = self.deploy_options.remote
branch = self.deploy_options.branch
strategy = self.deploy_options.strategy
commit_signature = "#{Middleman::Deploy::PACKAGE} #{Middleman::Deploy::VERSION}"
commit_time = "#{Time.now.utc}"
push_options = (strategy == :force_push ? ' -f' : nil)
puts "## Deploying via git to remote=\"#{remote}\" and branch=\"#{branch}\""
#check if remote is not a git url
unless remote =~ /\.git$/
remote = `git config --get remote.#{remote}.url`.chop
end
#if the remote name doesn't exist in the main repo
if remote == ''
puts "Can't deploy! Please add a remote with the name '#{self.deploy_options.remote}' to your repo."
exit
end
Dir.chdir(self.inst.build_dir) do
if strategy == :force_push
unless File.exists?('.git')
`git init`
`git remote add origin #{remote}`
else
#check if the remote repo has changed
unless remote == `git config --get remote.origin.url`.chop
`git remote rm origin`
`git remote add origin #{remote}`
end
end
end
#if there is a branch with that name, switch to it, otherwise create a new one and switch to it
if `git branch`.split("\n").any? { |b| b =~ /#{branch}/i }
`git checkout #{branch}`
else
`git checkout -b #{branch}`
end
if strategy == :submodule
`git fetch`
`git stash`
`git rebase #{self.deploy_options.remote}/#{branch}`
`git stash pop`
if $?.exitstatus == 1
puts "Can't deploy! Please resolve conflicts. Then process to manual commit and push on #{branch} branch."
exit
end
end
`git add -A`
`git commit --allow-empty -am "Automated commit at #{commit_time} by #{commit_signature}"`
`git push #{push_options} origin #{branch}`
end
if strategy == :submodule
current_branch = `git rev-parse --abbrev-ref HEAD`
`git add #{self.inst.build_dir}`
`git commit --allow-empty -m "Deployed at #{commit_time} by #{commit_signature}"`
`git push origin #{current_branch}`
end
end
def deploy_ftp
require 'net/ftp'
require 'ptools'
host = self.deploy_options.host
user = self.deploy_options.user
pass = self.deploy_options.password
path = self.deploy_options.path
puts "## Deploying via ftp to #{user}@#{host}:#{path}"
ftp = Net::FTP.new(host)
ftp.login(user, pass)
ftp.chdir(path)
ftp.passive = true
Dir.chdir(self.inst.build_dir) do
files = Dir.glob('**/*', File::FNM_DOTMATCH)
files.reject { |a| a =~ Regexp.new('\.$') }.each do |f|
if File.directory?(f)
begin
ftp.mkdir(f)
puts "Created directory #{f}"
rescue
end
else
begin
if File.binary?(f)
ftp.putbinaryfile(f, f)
else
ftp.puttextfile(f, f)
end
rescue Exception => e
reply = e.message
err_code = reply[0,3].to_i
if err_code == 550
if File.binary?(f)
ftp.putbinaryfile(f, f)
else
ftp.puttextfile(f, f)
end
end
end
puts "Copied #{f}"
end
end
end
ftp.close
end
def deploy_sftp
require 'net/sftp'
require 'ptools'
host = self.deploy_options.host
user = self.deploy_options.user
pass = self.deploy_options.password
path = self.deploy_options.path
puts "## Deploying via sftp to #{user}@#{host}:#{path}"
# `nil` is a valid value for user and/or pass.
Net::SFTP.start(host, user, :password => pass) do |sftp|
sftp.mkdir(path)
Dir.chdir(self.inst.build_dir) do
files = Dir.glob('**/*', File::FNM_DOTMATCH)
files.reject { |a| a =~ Regexp.new('\.$') }.each do |f|
if File.directory?(f)
begin
sftp.mkdir("#{path}/#{f}")
puts "Created directory #{f}"
rescue
end
else
begin
sftp.upload(f, "#{path}/#{f}")
rescue Exception => e
reply = e.message
err_code = reply[0,3].to_i
if err_code == 550
sftp.upload(f, "#{path}/#{f}")
end
end
puts "Copied #{f}"
end
end
end
end
end
end
# Alias "d" to "deploy"
Base.map({ "d" => "deploy" })
end
end

5
lib/middleman-deploy/methods.rb Normal file
View file

@ -0,0 +1,5 @@
require 'middleman-deploy/methods/base'
require 'middleman-deploy/methods/ftp'
require 'middleman-deploy/methods/git'
require 'middleman-deploy/methods/rsync'
require 'middleman-deploy/methods/sftp'

19
lib/middleman-deploy/methods/base.rb Normal file
View file

@ -0,0 +1,19 @@
module Middleman
module Deploy
module Methods
class Base
attr_reader :options, :server_instance
def initialize(server_instance, options={})
@options = options
@server_instance = server_instance
end
def process
raise NotImplementedError
end
end
end
end
end

101
lib/middleman-deploy/methods/ftp.rb Normal file
View file

@ -0,0 +1,101 @@
require 'net/ftp'
require 'ptools'
module Middleman
module Deploy
module Methods
class Ftp < Base
attr_reader :host, :pass, :path,:user
def initialize(server_instance, options={})
super(server_instance, options)
@host = self.options.host
@user = self.options.user
@pass = self.options.password
@path = self.options.path
end
def process
puts "## Deploying via ftp to #{self.user}@#{self.host}:#{self.path}"
ftp = open_connection
Dir.chdir(self.server_instance.build_dir) do
filtered_files.each do |filename|
if File.directory?(filename)
upload_directory(ftp, filename)
elsif File.binary?(filename)
upload_binary(ftp, filename)
else
upload_file(ftp, filename)
end
end
end
ftp.close
end
protected
def filtered_files
files = Dir.glob('**/*', File::FNM_DOTMATCH)
files.reject { |filename| filename =~ Regexp.new('\.$') }
end
def handle_exception(exception, ftp, filename)
reply = exception.message
err_code = reply[0,3].to_i
if err_code == 550
if File.binary?(filename)
ftp.putbinaryfile(filename, filename)
else
ftp.puttextfile(filename, filename)
end
end
end
def open_connection
ftp = Net::FTP.new(self.host)
ftp.login(self.user, self.pass)
ftp.chdir(self.path)
ftp.passive = true
ftp
end
def upload_binary(ftp, filename)
begin
ftp.putbinaryfile(filename, filename)
rescue Exception => exception
handle_exception(exception, ftp, filename)
end
puts "Copied #{filename}"
end
def upload_directory(ftp, filename)
begin
ftp.mkdir(filename)
puts "Created directory #{filename}"
rescue
end
end
def upload_file(ftp, filename)
begin
ftp.puttextfile(filename, filename)
rescue Exception => exception
handle_exception(exception, ftp, filename)
end
puts "Copied #{filename}"
end
end
end
end
end

19
lib/middleman-deploy/methods/git.rb Normal file
View file

@ -0,0 +1,19 @@
module Middleman
module Deploy
module Methods
class Git < Base
def process
puts "## Deploying via git to remote=\"#{self.options.remote}\" and branch=\"#{self.options.branch}\""
camelized_strategy = self.options.strategy.to_s.split('_').map { |word| word.capitalize}.join
strategy_class_name = "Middleman::Deploy::Strategies::Git::#{camelized_strategy}"
strategy_instance = strategy_class_name.constantize.new(self.server_instance.build_dir, self.options.remote, self.options.branch)
strategy_instance.process
end
end
end
end
end

38
lib/middleman-deploy/methods/rsync.rb Normal file
View file

@ -0,0 +1,38 @@
module Middleman
module Deploy
module Methods
class Rsync < Base
attr_reader :clean, :flags, :host, :path, :port, :user
def initialize(server_instance, options={})
super(server_instance, options)
@clean = self.options.clean
@flags = self.options.flags
@host = self.options.host
@path = self.options.path
@port = self.options.port
@user = self.options.user
end
def process
# Append "@" to user if provided.
user = "#{self.user}@" if self.user && !self.user.empty?
dest_url = "#{user}#{self.host}:#{self.path}"
flags = self.flags || '-avze'
command = "rsync #{flags} 'ssh -p #{self.port}' #{self.server_instance.build_dir}/ #{dest_url}"
if self.clean
command += " --delete"
end
puts "## Deploying via rsync to #{dest_url} port=#{self.port}"
run command
end
end
end
end
end

65
lib/middleman-deploy/methods/sftp.rb Normal file
View file

@ -0,0 +1,65 @@
require 'net/sftp'
require 'ptools'
module Middleman
module Deploy
module Methods
class Sftp < Ftp
def process
puts "## Deploying via sftp to #{self.user}@#{self.host}:#{path}"
# `nil` is a valid value for user and/or pass.
Net::SFTP.start(self.host, self.user, :password => self.pass) do |sftp|
sftp.mkdir(self.path)
Dir.chdir(self.server_instance.build_dir) do
filtered_files.each do |filename|
if File.directory?(filename)
upload_directory(sftp, filename)
else
upload_file(sftp, filename)
end
end
end
end
end
protected
def handle_exception(exception)
reply = exception.message
err_code = reply[0,3].to_i
if err_code == 550
sftp.upload(filename, file_path)
end
end
def upload_directory(sftp, filename)
file_path = "#{self.path}/#{filename}"
begin
sftp.mkdir(file_path)
puts "Created directory #{filename}"
rescue
end
end
def upload_file(sftp, filename)
file_path = "#{self.path}/#{filename}"
begin
sftp.upload(filename, file_path)
rescue Exception => exception
handle_exception(exception, file_path)
end
puts "Copied #{filename}"
end
end
end
end
end

3
lib/middleman-deploy/strategies.rb Normal file
View file

@ -0,0 +1,3 @@
require 'middleman-deploy/strategies/git/base'
require 'middleman-deploy/strategies/git/force_push'
require 'middleman-deploy/strategies/git/submodule'

48
lib/middleman-deploy/strategies/git/base.rb Normal file
View file

@ -0,0 +1,48 @@
module Middleman
module Deploy
module Strategies
module Git
class Base
attr_accessor :branch, :build_dir, :remote
def initialize(build_dir, remote, branch)
self.branch = branch
self.build_dir = build_dir
self.remote = remote
end
def process
raise NotImplementedError
end
protected
def add_signature_to_commit_message(base_message)
signature = "#{Middleman::Deploy::PACKAGE} #{Middleman::Deploy::VERSION}"
time = "#{Time.now.utc}"
"#{base_message} at #{time} by #{signature}"
end
def checkout_branch
# if there is a branch with that name, switch to it, otherwise create a new one and switch to it
if `git branch`.split("\n").any? { |b| b =~ /#{self.branch}/i }
`git checkout #{self.branch}`
else
`git checkout -b #{self.branch}`
end
end
def commit_branch(options='')
message = add_signature_to_commit_message('Automated commit')
`git add -A`
`git commit --allow-empty -am "#{message}"`
`git push #{options} origin #{self.branch}`
end
end
end
end
end
end

54
lib/middleman-deploy/strategies/git/force_push.rb Normal file
View file

@ -0,0 +1,54 @@
module Middleman
module Deploy
module Strategies
module Git
class ForcePush < Base
def process
Dir.chdir(self.build_dir) do
add_remote_url
checkout_branch
commit_branch('-f')
end
end
private
def add_remote_url
url = get_remote_url
unless File.exists?('.git')
`git init`
`git remote add origin #{url}`
else
# check if the remote repo has changed
unless url == `git config --get remote.origin.url`.chop
`git remote rm origin`
`git remote add origin #{url}`
end
end
end
def get_remote_url
remote = self.remote
url = remote
# check if remote is not a git url
unless remote =~ /\.git$/
url = `git config --get remote.#{url}.url`.chop
end
# if the remote name doesn't exist in the main repo
if url == ''
puts "Can't deploy! Please add a remote with the name '#{remote}' to your repo."
exit
end
url
end
end
end
end
end
end

44
lib/middleman-deploy/strategies/git/submodule.rb Normal file
View file

@ -0,0 +1,44 @@
module Middleman
module Deploy
module Strategies
module Git
class Submodule < Base
def process
Dir.chdir(self.build_dir) do
checkout_branch
pull_submodule
commit_branch
end
commit_submodule
end
private
def commit_submodule
current_branch = `git rev-parse --abbrev-ref HEAD`
message = add_signature_to_commit_message('Deployed')
`git add #{self.build_dir}`
`git commit --allow-empty -m "#{message}"`
`git push origin #{current_branch}`
end
def pull_submodule
`git fetch`
`git stash`
`git rebase #{self.remote}/#{self.branch}`
`git stash pop`
if $?.exitstatus == 1
puts "Can't deploy! Please resolve conflicts. Then process to manual commit and push on #{self.branch} branch."
exit
end
end
end
end
end
end
end