sinatra-s3 0.98

data/lib/sinatra-s3/helpers/admin.rb

@@ -0,0 +1,41 @@
+require 'aws/s3'
+
+module S3
+  module AdminHelpers
+
+    def login_required
+      @user = User.find(session[:user_id]) unless session[:user_id].nil?
+      redirect '/control/login' if @user.nil?
+    end
+
+    def number_to_human_size(size)
+      case
+      when size < 1.kilobyte: '%d Bytes' % size
+      when size < 1.megabyte: '%.1f KB'  % (size / 1.0.kilobyte)
+      when size < 1.gigabyte: '%.1f MB'  % (size / 1.0.megabyte)
+      when size < 1.terabyte: '%.1f GB'  % (size / 1.0.gigabyte)
+      else                    '%.1f TB'  % (size / 1.0.terabyte)
+      end.sub('.0', '')
+    rescue
+      nil
+    end
+
+    def signed_url(path)
+      url = "#{path}?"
+      url + AWS::S3::Authentication::QueryString.new(Net::HTTP::Get.new(path), @user.key, @user.secret)
+    end
+
+    def errors_for(model)
+      ret = ""
+      if model.errors.size > 0
+	ret += "<ul class=\"errors\">"
+	model.errors.each_full do |error|
+	  ret += "<li>#{error}</li>"
+	end
+	ret += "</ul>"
+      end
+      ret
+    end
+
+  end
+end

data/lib/sinatra-s3/helpers/tracker.rb

@@ -0,0 +1,42 @@
+require 'aws/s3'
+
+module S3
+  module TrackerHelper
+
+    def torrent(bit)
+      mi = bit.metainfo
+      mi.announce = URI("http://#{env['HTTP_HOST']}/tracker/announce")
+      mi.url_list = URI("http://#{env['HTTP_HOST']}/#{bit.parent.name}/#{bit.name}")
+      mi.created_by = "Served by Sinatra-S3/0.1a"
+      mi.creation_date = Time.now
+      t = Torrent.find_by_bit_id bit.id
+      info_hash = Digest::SHA1.digest(mi.info.to_bencoding).to_hex_s
+      unless t and t.info_hash == info_hash
+	t ||= Torrent.new
+	t.update_attributes(:info_hash => info_hash, :bit_id => bit.id, :metainfo => mi.to_bencoding)
+      end
+      status 200
+      headers 'Content-Disposition' => "attachment; filename=#{bit.name}.torrent;", 'Content-Type' => 'application/x-bittorrent'
+      body mi.to_bencoding
+    end
+
+    def torrent_list(info_hash)
+      params = {:order => 'seeders DESC, leechers DESC', :include => :bit}
+      params[:conditions] = ['info_hash = ?', info_hash.to_hex_s] if info_hash
+      Torrent.find :all, params
+    end
+
+    def tracker_reply(params)
+      status 200
+      headers 'Content-Type' => 'text/plain'
+      body params.merge('interval' => TRACKER_INTERVAL).to_bencoding
+    end
+
+    def tracker_error(msg)
+      status 200
+      headers 'Content-Type' => 'text/plain'
+      body ({'failure reason' => msg}.to_bencoding)
+    end
+
+  end
+end

data/lib/sinatra-s3/helpers/versioning.rb

@@ -0,0 +1,27 @@
+module S3
+  module Helpers
+    module Versioning
+
+      def versioning_response_for(bit)
+	xml do |x|
+	  x.VersioningConfiguration :xmlns => "http://s3.amazonaws.com/doc/2006-03-01/" do
+	    x.Versioning bit.versioning_enabled? ? 'Enabled' : 'Suspended' if File.exists?(File.join(bit.fullpath, '.git'))
+	  end
+	end
+      end
+
+      def manage_versioning(bucket)
+	raise NotImplemented unless defined?(Git)
+	only_can_write_acp bucket
+
+	env['rack.input'].rewind
+	data = env['rack.input'].read
+	xml_request = REXML::Document.new(data).root
+
+	bucket.git_init() if !bucket.versioning_enabled? && xml_request.elements['Status'].text == 'Enabled'
+	bucket.git_destroy() if bucket.versioning_enabled? && xml_request.elements['Status'].text == 'Suspended'
+      end
+
+    end
+  end
+end

data/lib/sinatra-s3/helpers.rb

@@ -0,0 +1,79 @@
+Dir["#{File.dirname(__FILE__)}/helpers/*.rb"].each {|r| require r }
+
+module S3
+  module Helpers
+
+    include ACP
+    include Versioning
+
+    # Kick out anonymous users.
+    def only_authorized; raise S3::AccessDenied unless @user end
+    # Kick out any users which do not have read access to a certain resource.
+    def only_can_read bit; raise S3::AccessDenied unless bit.readable_by? @user end
+    # Kick out any users which do not have write access to a certain resource.
+    def only_can_write bit; raise S3::AccessDenied unless bit.writable_by? @user end
+    # Kick out any users which do not own a certain resource.
+    def only_owner_of bit; raise S3::AccessDenied unless bit.owned_by? @user end
+    # Kick out any non-superusers
+    def only_superusers; raise S3::AccessDenied unless @user.superuser? end
+
+    protected
+    def load_buckets
+      @buckets = Bucket.find_by_sql [%{
+               SELECT b.*, COUNT(c.id) AS total_children
+               FROM bits b LEFT JOIN bits c ON c.parent_id = b.id AND c.deleted = 0
+               WHERE b.deleted = 0 AND b.parent_id IS NULL AND b.owner_id = ?
+               GROUP BY b.id ORDER BY b.name}, @user.id]
+      @bucket = Bucket.new(:owner_id => @user.id, :access => CANNED_ACLS['private'])
+    end
+
+    def xml
+      xml = Builder::XmlMarkup.new
+      xml.instruct! :xml, :version=>"1.0", :encoding=>"UTF-8"
+      yield xml
+      content_type 'text/xml'
+      body xml.target!
+    end
+
+    # Convenient method for generating a SHA1 digest.
+    def hmac_sha1(key, s)
+      ipad = [].fill(0x36, 0, 64)
+      opad = [].fill(0x5C, 0, 64)
+      key = key.unpack("C*")
+      if key.length < 64 then
+        key += [].fill(0, 0, 64-key.length)
+      end
+
+      inner = []
+      64.times { |i| inner.push(key[i] ^ ipad[i]) }
+      inner += s.unpack("C*")
+
+      outer = []
+      64.times { |i| outer.push(key[i] ^ opad[i]) }
+      outer = outer.pack("c*")
+      outer += Digest::SHA1.digest(inner.pack("c*"))
+
+      return Base64::encode64(Digest::SHA1.digest(outer)).chomp
+    end
+
+    def generate_secret
+      abc = %{ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789abcdefghijklmnopqrstuvwxyz}
+      (1..40).map { abc[rand(abc.size),1] }.join
+    end
+
+    def generate_key
+      abc = %{ABCDEF0123456789}
+      (1..20).map { abc[rand(abc.size),1] }.join
+    end
+
+    def get_prefix(c)
+      c.name.sub(params['prefix'], '').split(params['delimiter'])[0] + params['delimiter']
+    end
+
+    def r(name, title, layout = :layout)
+      @title = title
+      haml name, :layout => layout
+    end
+
+  end
+end

data/lib/sinatra-s3/models/bit.rb

@@ -0,0 +1,180 @@
+class Bit < ActiveRecord::Base
+
+  has_many :bits_users
+
+  serialize :meta
+  serialize :obj
+
+  belongs_to :parent, :class_name => 'Bit', :foreign_key => 'parent_id'
+  belongs_to :owner, :class_name => 'User', :foreign_key => 'owner_id'
+
+  validates_length_of :name, :within => 3..255
+
+  has_one :torrent
+
+  def git_repository
+    versioning_enabled? ? Git.open(git_repository_path) : nil
+  end
+
+  def fullpath; File.join(S3::STORAGE_PATH, name) end
+
+  def git_repository_path
+    self.obj ? File.join(File.dirname(self.fullpath)) : self.fullpath
+  end
+
+  def versioning_enabled?
+    return false if !defined?(Git) || !File.exists?(File.join(git_repository_path,'.git'))
+    return false if File.exists?(File.join(git_repository_path,'.git', 'disable_versioning'))
+    return true
+  end
+
+  def git_object
+    git_repository.log.path(File.basename(self.obj.path)).first if versioning_enabled? && self.obj
+  end
+
+  def objectish
+    git_repository.gcommit(version).gtree.blobs[File.basename(fullpath)].objectish
+  end
+
+  def diff(to)
+    to = Bit.find_by_version(to) if to.instance_of?(String)
+    git_repository.diff(objectish, to.objectish)
+  end
+
+  def self.diff(from,to)
+    from = Bit.find_by_version(from)
+    to = Bit.find_by_version(to)
+    from.git_repository.diff(from.objectish, to.objectish)
+  end
+
+  def acl_list
+    bit_perms = self.access.nil? ? "000" : self.access.to_s(8)
+    acls = { :owner => { :id => self.owner.key, :accessnum => 7, :type => "CanonicalUser", :name => self.owner.login, :access => "FULL_ACCESS" },
+      :anonymous => { :id => nil, :accessnum => bit_perms[2,1], :access => acl_label(bit_perms[2,1]),
+	:type => "Group", :uri => "http://acs.amazonaws.com/groups/global/AllUsers" },
+	:authenticated => { :id => nil, :accessnum => bit_perms[1,1], :access => acl_label(bit_perms[1,1]),
+	  :type => "Group", :uri => "http://acs.amazonaws.com/groups/global/AuthenticatedUsers" }
+    }.merge(get_acls_for_bin)
+    acls.delete_if { |key,value| value[:access] == "NONE" || (key == :authenticated && (!acls[:anonymous].nil? && value[:accessnum] <= acls[:anonymous][:accessnum])) }
+  end
+
+  def get_acls_for_bin
+    ret = {}
+    for a in self.bits_users
+      ret[a.user.key] = { :type => "CanonicalUser", :id => a.user.key, :name => a.user.login, :access => acl_label(a.access.to_s(8)[0,1]),
+	:accessnum => a.access.to_s(8)[0,1] }
+    end
+    ret
+  end
+
+  def self.acl_text
+    { 0 => "NONE", 1 => "NONE", 2 => "NONE", 3 => "NONE", 4 => "READ", 5 => "READ_ACP", 6 => "WRITE", 7 => "WRITE_ACP" }
+  end
+
+  def acl_label(num)
+    Bit.acl_text[num.to_i]
+  end
+
+  def grant hsh
+    if hsh[:access]
+      self.access = hsh[:access]
+      self.save
+    end
+  end
+
+  def access_readable
+    name, _ = S3::CANNED_ACLS.find { |k, v| v == self.access }
+    if name
+      name
+    else
+      [0100, 0010, 0001].map do |i|
+	[[4, 'r'], [2, 'w'], [1, 'x']].map do |k, v|
+	  (self.access & (i * k) == 0 ? '-' : v )
+	end
+      end.join
+    end
+  end
+
+  def acp_readable_by? user
+    # if owner
+    return true if user && user == owner
+    # if can write or better
+    return true if user && acl_list[user.key] && acl_list[user.key][:accessnum].to_i >= 5
+    # if authenticated
+    return true if user && acl_list[:authenticated] && acl_list[:authenticated][:accessnum].to_i >= 5
+    # if anonymous
+    return true if acl_list[:anonymous] && acl_list[:anonymous][:accessnum].to_i >= 5
+  end
+
+  def acp_writable_by? user
+    # if owner
+    return true if user && user == owner
+    # if can write or better
+    return true if user && acl_list[user.key] && acl_list[user.key][:accessnum].to_i == 7
+    # if authenticated
+    return true if user && acl_list[:authenticated] && acl_list[:authenticated][:accessnum].to_i == 7
+    # if anonymous
+    return true if acl_list[:anonymous] && acl_list[:anonymous][:accessnum].to_i == 7
+  end
+
+  def readable_by? user
+    return true if user && acl_list[user.key] && acl_list[user.key][:accessnum].to_i >= 4
+    check_access(user, S3::READABLE_BY_AUTH, S3::READABLE)
+  end
+
+  def writable_by? user
+    return true if user && acl_list[user.key] && acl_list[user.key][:accessnum].to_i >= 6
+    check_access(user, S3::WRITABLE_BY_AUTH, S3::WRITABLE)
+  end
+
+  def check_access user, group_perm, user_perm
+    !!( if owned_by?(user) or (user and access & group_perm > 0) or (access & user_perm > 0)
+       true
+    elsif user
+      acl = users.find(user.id) rescue nil
+      acl and acl.access.to_i & user_perm
+    end )
+  end
+
+  def owned_by? user
+    user and owner_id == user.id
+  end
+
+  def git_update
+    # update git info so we can serve it over http
+    base_dir = File.join(self.git_repository_path,'.git')
+    if File.exists?(base_dir)
+      File.open(File.join(base_dir,'HEAD'),'w') { |f| f.write("ref: refs/heads/master") }
+      if File.exists?(File.join(base_dir,'refs/heads/master'))
+        File.open(File.join(base_dir,'info/refs'),'w') { |f|
+  	  ref = File.open(File.join(base_dir,'refs/heads/master')) { |re| re.read }
+	  f.write("#{ref.chomp}\trefs/heads/master\n")
+        }
+      end
+    end
+  end
+
+  def each_piece(files, length)
+     buf = ""
+     files.each do |f|
+         File.open(f) do |fh|
+             begin
+                 read = fh.read(length - buf.length)
+                 if (buf.length + read.length) == length
+                     yield(buf + read)
+                     buf = ""
+                 else
+                     buf += read
+                 end
+             end until fh.eof?
+         end
+     end
+     yield buf
+  end
+
+end
+
+class BitsUser < ActiveRecord::Base
+  belongs_to :bit
+  belongs_to :user
+end

data/lib/sinatra-s3/models/bucket.rb

@@ -0,0 +1,81 @@
+class Bucket < Bit
+
+  named_scope :user_buckets, lambda { |uid| { :conditions => ['parent_id IS NULL AND owner_id = ?', uid ], :order => "name" } }
+  named_scope :root, lambda { |name| { :conditions => ['deleted = 0 AND parent_id IS NULL AND name = ?', name] } }
+
+  def items(marker,prefix)
+    Slot.bucket(self).items(marker,prefix)
+  end
+
+  def self.find_root(bucket_name)
+    root(bucket_name).find(:first) or raise S3::NoSuchBucket
+  end
+
+  def find_slot(oid)
+    Slot.find(:first, :conditions => ['deleted = 0 AND parent_id = ? AND name = ?', self.id, oid]) or raise S3::NoSuchKey
+  end
+
+  def remove_from_filesystem
+    bucket_dir = File.join(S3::STORAGE_PATH, self.name)
+    FileUtils.rm_rf bucket_dir if File.directory?(bucket_dir) && Dir.empty?(bucket_dir)
+  end
+
+  def git_disable
+    FileUtils.touch(File.join(self.fullpath, '.git', 'disable_versioning'))
+  end
+
+  def add_child(bit)
+    bit.update_attributes(:parent_id => self.id)
+  end
+
+  def git_init
+    disable_file = File.join(self.fullpath, '.git', 'disable_versioning')
+    FileUtils.rm_f(disable_file) and return if File.exists?(disable_file)
+
+    begin
+      FileUtils.mkdir_p(self.fullpath) unless File.exists?(self.fullpath)
+      dir_empty = !Dir.foreach(self.fullpath) {|n| break true unless /\A\.\.?\z/ =~ n}
+      g = Git.init(self.fullpath)
+      g.config('user.name', self.owner.login)
+      g.config('user.email', self.owner.email)
+      # if directory is not empty we need to add the files
+      # into version control
+      unless dir_empty
+	g.add('.')
+	g.commit_all("Enabling versioning for bucket #{self.name}.")
+	self.git_update
+      end
+      self.type = "GitBucket"
+      self.save()
+      self.git_update
+    rescue Git::GitExecuteError => error_message
+      puts "[#{Time.now}] GIT: #{error_message}" 
+    end
+  end
+
+  def metainfo
+    children = self.all_children
+    mii = RubyTorrent::MetaInfoInfo.new
+    mii.name = self.name
+    mii.piece_length = 512.kilobytes
+    mii.files, files = [], []
+    mii.pieces = ""
+    i = 0
+    Slot.find(:all, :conditions => ['parent_id = ?', self.id]).each do |slot|
+      miif = RubyTorrent::MetaInfoInfoFile.new
+      miif.length = slot.obj.size
+      miif.md5sum = slot.obj.md5
+      miif.path = File.split(slot.name)
+      mii.files << miif
+      files << slot.fullpath
+    end
+    each_piece(files, mii.piece_length) do |piece|
+      mii.pieces += Digest::SHA1.digest(piece)
+      i += 1
+    end
+    mi = RubyTorrent::MetaInfo.new
+    mi.info = mii
+    mi
+  end
+
+end

data/lib/sinatra-s3/models/file_info.rb

@@ -0,0 +1,3 @@
+class FileInfo
+  attr_accessor :path, :mime_type, :disposition, :size, :md5, :etag
+end

data/lib/sinatra-s3/models/git_bucket.rb

@@ -0,0 +1,3 @@
+class GitBucket < Bucket
+
+end

data/lib/sinatra-s3/models/slot.rb

@@ -0,0 +1,47 @@
+class Slot < Bit
+
+  named_scope :bucket, lambda { |bucket| { :conditions => [ 'bits.deleted = 0 AND parent_id = ?', bucket.id ], :order => "name" } }
+  named_scope :items, lambda { |marker,prefix| { :conditions => condition_string(marker,prefix) } }
+
+  def fullpath; File.join(S3::STORAGE_PATH, obj.path) end
+
+  def etag
+    if self.obj.respond_to? :etag
+      self.obj.etag
+    elsif self.obj.respond_to? :md5
+      self.obj.md5
+    else
+      %{"#{MD5.md5(self.obj)}"}
+    end
+  end
+
+  def remove_from_filesystem
+    FileUtils.rm_f fullpath
+  end
+
+  def metainfo
+    mii = RubyTorrent::MetaInfoInfo.new
+    mii.name = self.name
+    mii.length = self.obj.size
+    mii.md5sum = self.obj.md5
+    mii.piece_length = 512.kilobytes
+    mii.pieces = ""
+    i = 0
+    each_piece([self.fullpath], mii.piece_length) do |piece|
+      mii.pieces += Digest::SHA1.digest(piece)
+      i += 1
+    end
+    mi = RubyTorrent::MetaInfo.new
+    mi.info = mii
+    mi
+  end
+
+  protected
+  def self.condition_string(marker,prefix)
+    conditions = []
+    conditions << "name LIKE '#{prefix.gsub(/\\/, '\&\&').gsub(/'/, "''")}%'" unless prefix.blank?
+    conditions << "name > '#{marker.gsub(/\\/, '\&\&').gsub(/'/, "''")}'" unless marker.blank?
+    conditions.empty? ? nil : conditions.join(" AND ")
+  end
+
+end

data/lib/sinatra-s3/models/torrent.rb

@@ -0,0 +1,6 @@
+class Torrent < ActiveRecord::Base
+
+  belongs_to :bit
+  has_many :torrent_peers
+
+end

data/lib/sinatra-s3/models/torrent_peer.rb

@@ -0,0 +1,5 @@
+class TorrentPeer < ActiveRecord::Base
+
+  belongs_to :torrent
+
+end

data/lib/sinatra-s3/models/user.rb

@@ -0,0 +1,35 @@
+require File.join(File.dirname(__FILE__), '..', 'helpers.rb')
+
+class User < ActiveRecord::Base
+
+  include S3::Helpers
+
+  has_many :bits, :foreign_key => 'owner_id'
+  has_many :bits_users
+
+  validates_length_of :login, :within => 3..40
+  validates_uniqueness_of :login
+  validates_uniqueness_of :key
+  validates_presence_of :password
+  validates_confirmation_of :password
+
+  def destroy
+    self.deleted = 1
+    self.save
+  end
+
+  attr_accessor :skip_before_save
+
+  protected
+  def before_save
+    unless self.skip_before_save
+      @password_clean = self.password
+      self.password = hmac_sha1(self.password, self.secret)
+    end
+  end
+
+  def after_save
+    self.password = @password_clean
+  end
+
+end

data/lib/sinatra-s3/s3.rb

@@ -0,0 +1,57 @@
+require 'rubygems'
+require 'activerecord'
+
+require 'sinatra/base'
+require 'openssl'
+require 'digest/sha1'
+require 'md5'
+require 'haml'
+
+begin
+  require "git"
+  puts "-- Git support found, versioning support enabled." if $VERBOSE
+rescue LoadError
+  puts "-- Git support not found, versioning support disabled."
+end
+
+begin
+  require 'exifr'
+  puts "-- EXIFR found, JPEG metadata enabled." if $VERBOSE
+rescue LoadError
+  puts "-- EXIFR not found, JPEG metadata disabled."
+end
+
+begin
+  require 'rubytorrent'
+  puts "-- RubyTorrent support found, bittorrent support enabled." if $VERBOSE
+rescue LoadError
+  puts "-- RubyTorrent support not found, bittorrent support disabled."
+end
+
+module S3
+  VERSION = "0.98"
+  DEFAULT_PASSWORD = 'pass@word1'
+
+  BUFSIZE = (4 * 1024)
+  ROOT_DIR = File.expand_path(File.join(File.dirname(__FILE__), '..', '..'))
+  PUBLIC_PATH = File.join(ROOT_DIR, 'public')
+  STORAGE_PATH = File.expand_path('storage') unless defined?(STORAGE_PATH)
+  RESOURCE_TYPES = %w[acl versioning torrent]
+  CANNED_ACLS = {
+    'private' => 0600,
+    'public-read' => 0644,
+    'public-read-write' => 0666,
+    'authenticated-read' => 0640,
+    'authenticated-read-write' => 0660
+  }
+  READABLE = 0004
+  WRITABLE = 0002
+  READABLE_BY_AUTH = 0040
+  WRITABLE_BY_AUTH = 0020
+
+  POST = %{if(!this.title||confirm(this.title+'?')){var f = document.createElement('form'); this.parentNode.appendChild(f); f.method = 'POST'; f.action = this.href; f.submit();}return false;}
+  POPUP = %{window.open(this.href,'changelog','height=600,width=500,scrollbars=1');return false;}
+end
+
+%w(bit bucket git_bucket slot user file_info torrent torrent_peer).each {|r| require "#{File.dirname(__FILE__)}/models/#{r}" }
+%w(ext helpers errors admin base tracker).each {|r| require "#{File.dirname(__FILE__)}/#{r}"}

data/lib/sinatra-s3/tasks.rb

@@ -0,0 +1,62 @@
+require 'rake'
+require 'rake/testtask'
+require 'rake/gempackagetask'
+require File.join(File.dirname(__FILE__), 's3')
+
+namespace :db do
+  task :environment do
+    ActiveRecord::Base.establish_connection(S3.config[:db])
+  end
+
+  desc "Migrate the database"
+  task(:migrate => :environment) do
+    ActiveRecord::Base.logger = Logger.new(STDOUT)
+    ActiveRecord::Migration.verbose = true
+
+    out_dir = File.dirname(S3.config[:db][:database])
+    FileUtils.mkdir_p(out_dir) unless File.exists?(out_dir)
+
+    ActiveRecord::Migrator.migrate(File.join(S3::ROOT_DIR, 'db', 'migrate'))
+    num_users = User.count || 0
+    if num_users == 0
+      puts "** No users found, creating the `admin' user."
+      class S3KeyGen
+	include S3::Helpers
+	def secret() generate_secret(); end;
+	def key() generate_key(); end;
+      end
+      User.create :login => "admin", :password => S3::DEFAULT_PASSWORD,
+	:email => "admin@parkplace.net", :key => S3KeyGen.new.key(), :secret => S3KeyGen.new.secret(),
+	:activated_at => Time.now, :superuser => 1
+    end
+  end
+end
+
+namespace :setup do
+  task :wiki do
+    begin
+      Bucket.find_root('wiki')
+    rescue S3::NoSuchBucket
+      wiki_owner = User.find_by_login('wiki')
+      if wiki_owner.nil?
+	class S3KeyGen
+	  include S3::Helpers
+	  def secret() generate_secret(); end;
+	  def key() generate_key(); end;
+	end
+	puts "** No wiki user found, creating the `wiki' user."
+	wiki_owner = User.create :login => "wiki", :password => S3::DEFAULT_PASSWORD,
+	  :email => "wiki@parkplace.net", :key => S3KeyGen.new.key(), :secret => S3KeyGen.new.secret(),
+	  :activated_at => Time.now
+      end
+      wiki_bucket = Bucket.create(:name => 'wiki', :owner_id => wiki_owner.id, :access => 438)
+      templates_bucket = Bucket.create(:name => 'templates', :owner_id => wiki_owner.id, :access => 438)
+      if defined?(Git)
+	wiki_bucket.git_init
+	templates_bucket.git_init
+      else
+	puts "Git support not found therefore Wiki history is disabled."
+      end
+    end
+  end
+end