dreamback 0.0.1

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.rbenv-version

@@ -0,0 +1 @@
+1.8.7-p352

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in dreamback.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Paul R Alexander
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,34 @@
+# Dreamback
+
+Dreamback is the easiest way to automate your backups on dreamhost. Dreamhost does not guarantee their backups of your users (though they've saved me with backups before), so it's best to run backups yourself.
+
+Using Dreamback is easy:
+
+1. Create a user on dreamhost to schedule your backups
+2. Log in with your new user
+3. `gem install dreamback`
+4. `dreamback`
+5. Answer the questions to setup your automated backup
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'dreamback'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install dreamback
+
+## Usage
+
+Run `dreamback` to configure automated backups.
+Run `dreamback backup` to immediately run a backup.
+
+## Contributing
+
+I'm happy to take pull or feature requests. Use the Github issue tracker if you have suggestions or need help.

data/Rakefile

@@ -0,0 +1,2 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"

data/bin/dreamback

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+
+require 'dreamback'

data/dreamback.gemspec

@@ -0,0 +1,24 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/dreamback/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Paul R Alexander"]
+  gem.email         = ["palexander@stanford.edu"]
+  gem.description   = %q{The easiest, cheapest way to back up your dreamhost accounts}
+  gem.summary       = %q{Dreamback is the easiest way to automate your backups on dreamhost. Dreamhost does not guarantee their backups of your users (though they've saved me with backups before), so it's best to run backups yourself.}
+  gem.homepage      = "https://github.com/palexander/dreamback"
+
+  gem.files         = `git ls-files`.split($\)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.name          = "dreamback"
+  gem.require_paths = ["lib"]
+  gem.version       = Dreamback::VERSION
+
+  gem.add_dependency("json")
+  gem.add_dependency("net-sftp")
+  gem.add_dependency("cronedit")
+  gem.add_dependency("commander")
+
+  gem.executables = %w(dreamback)
+end

data/lib/dreamback/backup.rb

@@ -0,0 +1,99 @@
+require 'net/sftp'
+
+module Dreamback
+  class Backup
+    BACKUP_FOLDER = "./dreamback"
+
+    # Manage the backup process
+    def self.start
+      # rotate the backup folders
+      backup_to_link = rotate_backups
+      # rsync backup of dreamhost user accounts
+      rsync_backup(backup_to_link)
+      # mysql backup
+      # TODO: Add mysql backups
+    end
+
+    # Rotate out the backups that are past our limit
+    # @returns [String] name of the most recent folder to link against
+    def self.rotate_backups
+      backup_to_link = ""
+      Net::SFTP.start(Dreamback.settings[:backup_server], Dreamback.settings[:backup_server_user]) do |sftp|
+        # Create the backup folder if it doesn't exist
+        backup_folder_exists = false
+        begin
+          sftp.stat!(BACKUP_FOLDER) do |response|
+            backup_folder_exists = response.ok?
+          end
+        rescue Net::SFTP::StatusException => e
+          backup_folder_exists = false if e.code == 2
+        end
+
+        # Get a list of all backup directories
+        backup_folders = []
+        if backup_folder_exists
+          sftp.dir.foreach(BACKUP_FOLDER) do |entry|
+            # Names should be like "dreamback.20120520", so we can sort on the folder name
+            backup_folders << [ entry.name, entry.name.split(".")[1].to_i ] if entry.name.include?("dreamback")
+            backup_folders.sort! {|a,b| b <=> a}
+          end
+        end
+
+        # Get the newest folder for linking
+        backup_to_link = backup_folders.first[0]
+
+        # Delete any folders older than our limit
+        # Subtract one to account for the folder we're about to create
+        # Normally we remove a folder so that our count is one less than the "days to keep"
+        # However, if today's folder already exists then there's no need
+        offset = backup_folders.include?("dreamback.#{Time.now.strftime("%Y%m%d")}") ? 0 : 1
+        if backup_folders.length >= Dreamback.settings[:days_to_keep] - offset
+          folders_to_delete = backup_folders.slice(Dreamback.settings[:days_to_keep] - offset, backup_folders.length)
+          folders_to_delete.map! {|f| f[0]}
+          rsync_delete(folders_to_delete)
+        end
+      end
+      backup_to_link
+    end
+
+    # This uses a hack where we sync an empty directory to remove files
+    # We do this because sftp has no recursive delete method
+    def self.rsync_delete(directories)
+      empty_dir_path = File.expand_path("../.dreamback_empty_dir", __FILE__)
+      empty_dir = Dir.mkdir(empty_dir_path) unless File.exists?(empty_dir_path)
+      begin
+        directories.each do |dir|
+          `rsync --delete -a #{empty_dir_path}/ #{Dreamback.settings[:backup_server_user]}@#{Dreamback.settings[:backup_server]}:#{BACKUP_FOLDER}/#{dir}`
+          Net::SFTP.start(Dreamback.settings[:backup_server], Dreamback.settings[:backup_server_user]) do |sftp|
+            sftp.rmdir!("#{BACKUP_FOLDER}/#{dir}")
+          end
+        end
+      ensure
+        Dir.delete(empty_dir_path)
+      end
+    end
+
+    # Sync to the backup server using link-dest to save space
+    # @param [String] name of the most recent backup folder prior to starting this run to link against
+    def self.rsync_backup(link_dir)
+      backup_server_user = Dreamback.settings[:backup_server_user]
+      backup_server = Dreamback.settings[:backup_server]
+      today = Time.now.strftime("%Y%m%d")
+      Dreamback.settings[:dreamhost_users].each do |dreamhost|
+        # User that we're going to back up
+        user = dreamhost[:user]
+        server = dreamhost[:server]
+        # rsync won't do remote<->remote syncing, so we stage everything here first
+        tmp_dir = File.expand_path("~/.dreamback_tmp")
+        Dir.mkdir(tmp_dir) unless File.exists?(tmp_dir)
+        `rsync -e ssh -av --keep-dirlinks --copy-links #{user}@#{server}:~/ #{tmp_dir}/#{user}@#{server}`
+        # Now we can sync local to remote
+        # Only use link-dest if a previous folder to link to exists
+        link_dest = link_dir.nil? ? "" : "--link-dest=~#{BACKUP_FOLDER.gsub(".", "")}/#{link_dir}"
+        `rsync -e ssh -av --delete --copy-links --keep-dirlinks #{link_dest} #{tmp_dir}/ #{backup_server_user}@#{backup_server}:#{BACKUP_FOLDER}/dreamback.#{today}`
+        # Remove the staging directory
+        `rm -rf #{tmp_dir}`
+      end
+    end
+  end
+end

data/lib/dreamback/base.rb

@@ -0,0 +1,22 @@
+program :version, Dreamback::VERSION
+program :description, 'Automated backup for dreamhost accounts'
+
+default_command :setup
+
+command :setup do |c|
+  c.syntax = 'dreamback start [options]'
+  c.summary = 'This will guide you through setting up Dreamback'
+  c.action do |args, options|
+    Dreamback::Initializer.setup
+  end
+end
+
+command :backup do |c|
+  c.syntax = 'dreamback backup'
+  c.summary = 'Run a backup process immediately. This command can also be added to a cron job.'
+  c.action do |args, options|
+    Dreamback::Initializer.setup
+    Dreamback::Backup.start
+  end
+end
+

data/lib/dreamback/exclusions.txt

@@ -0,0 +1,13 @@
+bin
+cgi-bin
+include
+jabber
+php5
+php5dist
+php5source
+share
+lib
+logs
+mail
+Maildir
+tmp

data/lib/dreamback/initializer.rb

@@ -0,0 +1,184 @@
+require 'json'
+require 'net/sftp'
+require 'cronedit'
+
+module Dreamback
+  @settings
+
+  def self.settings
+    @settings
+  end
+
+  def self.settings=(settings)
+    @settings=settings
+  end
+
+  class Initializer
+    SETTINGS_LOCATION = File.expand_path("~/.dreamback")
+
+    DEFAULT_SETTINGS = {
+      :backup_server => "",
+      :backup_server_user => "",
+      :dreamhost_users => [ {:user => "", :server => ""} ]
+    }
+
+    @settings = {}
+
+    # Walks a user through the initial setup process
+    def self.setup
+      # Check to see if settings exist
+      load_settings(SETTINGS_LOCATION)
+
+      # Ask user questions if no settings file
+      if @settings.nil? || @settings.empty?
+        create_new_settings
+        save_settings(SETTINGS_LOCATION)
+      else
+        say(bold("You have already setup Dreamback. Please run \"dreamback backup\" to start a backup."))
+      end
+
+      # Create ssh keys if they don't exist
+      ssh_keys_exist = File.exists?(File.expand_path("~/.ssh/id_dsa"))
+      create_ssh_keys unless ssh_keys_exist
+
+      # Copy ssh keys to backup server
+      unless @settings[:copied_backup_server_ssh_keys]
+        say(bold("Copying the ssh key to your backup server, type in your password if prompted for #{@settings[:backup_server_user]}@#{@settings[:backup_server]}"))
+        overwrite_keys = agree(bold("WARNING: ") + "This will overwrite existing ssh keys on your backup user account. Proceed? [y/n]: ")
+        if overwrite_keys
+          sftp_password = ask("Password for #{@settings[:backup_server_user]}@#{@settings[:backup_server]}: ") { |q| q.echo = "*" }
+          sftp_ssh_key_upload(sftp_password)
+        else
+          say("You will need to add the ssh key yourself to automate backups")
+        end
+        @settings[:copied_backup_server_ssh_keys] = true
+      end
+
+      # Copy ssh keys to dreamhost servers
+      unless @settings[:copied_dreamhost_users_ssh_keys]
+        say(bold("Copying the ssh key to the dreamhost accounts you want to back up"))
+        @settings[:dreamhost_users].each do |dreamhost|
+          say(bold("Type in password if prompted for #{dreamhost[:user]}@#{dreamhost[:server]}"))
+          `ssh-copy-id -i #{dreamhost[:user]}@#{dreamhost[:server]}`
+        end
+        @settings[:copied_dreamhost_users_ssh_keys] = true
+      end
+
+      # Setup a cron job if the user would like to
+      unless @settings[:cron_setup_completed]
+        setup_cron = agree(bold("Would you like to add a cron job to automatically run the backup? [y/n]: "))
+        if setup_cron
+          crontab_email = ask("Dreamhost requires an email address to send crontab output to, please provide one: ") { |q| q.validate = /\b[A-Za-z0-9._%-\+]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,4}\b/ }
+          ct = File.open(File.expand_path("~/.dreamback_crontab"), "w+")
+          ct << "MAILTO=#{crontab_email}\n"
+          ct << "0 1 * * * dreamback backup"
+          ct.close
+          `crontab #{ct.path}`
+          File.delete(ct.path)
+          say("Cron job added. Backups will run at 1:00am Pacific every day.")
+        end
+        @settings[:cron_setup_completed] = true
+      end
+
+      save_settings(SETTINGS_LOCATION)
+
+      # Set global settings
+      Dreamback.settings = @settings
+    end
+
+    private
+
+    # Dreamhost doesn't allow ssh shell access, so use sftp to write to the authorized_key file
+    # @param [String] password for backup user
+    def self.sftp_ssh_key_upload(sftp_password)
+      Net::SFTP.start(@settings[:backup_server], @settings[:backup_server_user], :password => sftp_password) do |sftp|
+        # Create the .ssh folder if it doesn't exist
+        ssh_folder_exists = false
+        begin
+          sftp.stat!(".ssh") do |response|
+            ssh_folder_exists = response.ok?
+          end
+        rescue Net::SFTP::StatusException => e
+          ssh_folder_exists = false if e.code == 2
+        end
+
+        unless ssh_folder_exists
+          sftp.mkdir!(".ssh")
+        end
+
+        sftp.file.open(".ssh/authorized_keys", "w+") do |f|
+          f.write File.open(File.expand_path("~/.ssh/id_dsa.pub"), "r").read
+        end
+      end
+    end
+
+    # Ask the user for settings
+    def self.create_new_settings
+      settings = {}
+      say("#{bold("Server Where We Should Store Your Backup")}\nYour dreamhost backup-specific account will work best, but any POSIX server with rsync should work\n<%= color('Note:', BOLD)%> dreamhost does not allow you to store non-webhosted data except your BACKUP-SPECIFIC account")
+      settings[:backup_server] = ask("Server name: ")
+      settings[:backup_server_user] = ask(bold("Username for the backup server: "))
+      settings[:dreamhost_users] = []
+      another_user = true
+      while another_user
+        dreamhost = {}
+        dreamhost[:user] = ask(bold("Dreamhost user to back up: "))
+        dreamhost[:server] = ask(bold("Server where the dreamhost user is located: "))
+        settings[:dreamhost_users] << dreamhost
+        another_user = agree(bold("Add another dreamhost account? [y/n]"))
+      end
+      settings[:days_to_keep] = ask(bold("How many days of backups do you want to keep [1-30]? "), Integer) {|q| q.in = 1..30}
+      @settings = settings
+    end
+
+    # Create ssh keys for user when they don't exist
+    def self.create_ssh_keys
+      ssh_key_location = File.expand_path("~/.ssh/id_dsa")
+      say(bold("You are missing a DSA ssh key for this user at #{ssh_key_location}, we will create one now"))
+      say("More on creating ssh keys here: http://en.wikipedia.org/wiki/ssh-keygen")
+      `ssh-keygen -t dsa`
+      success = File.exists?(ssh_key_location)
+      if success
+        say(bold("Key created successfully"))
+      else
+        try_again = agree(bold("It looks like the ssh key creation failed, try again? [y/n]"))
+        if try_again
+          create_ssh_keys
+        else
+          say("Please try running the setup process again")
+          exit
+        end
+      end
+    end
+
+    # Load settings from a JSON file
+    # @param [String] path where settings are located
+    def self.load_settings(settings_path)
+      settings_file = File.open(settings_path, "r") if File.exists?(settings_path)
+      @settings = JSON.parse(settings_file.read, :symbolize_names => true) unless settings_file.nil?
+      settings_file.close unless settings_file.nil?
+      @settings
+    end
+
+    # Store settings from a JSON file
+    # @param [String] path where settings are located
+    def self.save_settings(settings_path)
+      settings = @settings ||= ""
+      settings_file = File.open(settings_path, "w+")
+      settings_file << JSON.pretty_generate(settings)
+      settings_file.close
+      true
+    end
+
+    # Setter used primarily in testing
+    def self.settings=(settings)
+      @settings = settings
+    end
+
+    def self.bold(text)
+      "<%= color('\n#{text.gsub("'", "\\'")}', BOLD) %>"
+    end
+
+  end
+
+end

data/lib/dreamback/version.rb

@@ -0,0 +1,3 @@
+module Dreamback
+  VERSION = "0.0.1"
+end

data/lib/dreamback.rb

@@ -0,0 +1,18 @@
+# Use this file with a regular ruby setup (IE not from command line or bin/dreamback)
+
+begin
+  # Try loading without rubygems
+  require 'commander/import'
+  require 'dreamback/version'
+  require 'dreamback/initializer'
+  require 'dreamback/backup'
+  require 'dreamback/base'
+rescue LoadError
+  # If that fails, then load with it
+  require 'rubygems'
+  require 'commander/import'
+  require File.expand_path('../dreamback/version.rb', __FILE__)
+  require File.expand_path('../dreamback/initializer.rb', __FILE__)
+  require File.expand_path('../dreamback/backup.rb', __FILE__)
+  require File.expand_path('../dreamback/base.rb', __FILE__)
+end

data/test/dreamback_test.rb

@@ -0,0 +1,58 @@
+require "rubygems"
+require "test/unit"
+require File.expand_path('../../lib/dreamback/initializer', __FILE__)
+require "json"
+
+# Used for testing private methods
+class Class
+  def publicize_methods
+    saved_private_instance_methods = self.private_instance_methods
+    self.class_eval { public *saved_private_instance_methods }
+    yield
+    self.class_eval { private *saved_private_instance_methods }
+  end
+end
+
+class DreambackTest < Test::Unit::TestCase
+
+  def test_settings_save
+    settings = {:testing_settings_save => "worked"}
+    settings_file = File.open("./test_settings.json", "w+")
+    Dreamback::Initializer.publicize_methods do
+      Dreamback::Initializer.settings = settings
+      Dreamback::Initializer.save_settings(settings_file.path)
+    end
+    settings_new = JSON.parse(settings_file.read, :symbolize_names => true)
+    assert_equal settings, settings_new
+    settings_file.close
+    File.delete(settings_file.path)
+  end
+
+  def test_settings_load
+    file = File.open(File.expand_path('../mock/settings.json', __FILE__), "r")
+    settings_file = Dreamback::Initializer.load_settings(file.path)
+    settings_test =<<-EOS
+      {
+        "backup_server_user": "blah",
+        "dreamhost_users": [
+          {
+            "user": "u",
+            "server": "d1.dev"
+          },
+          {
+            "user": "u2",
+            "server": "d2.dev"
+          },
+          {
+            "user": "u3",
+            "server": "d3.dev"
+          }
+        ],
+        "days_to_keep": 7,
+        "backup_server": "backup.dev"
+      }
+    EOS
+    assert_equal settings_file, JSON.parse(settings_test, :symbolize_names => true)
+  end
+
+end

data/test/mock/settings.json

@@ -0,0 +1,19 @@
+{
+  "backup_server_user": "blah",
+  "dreamhost_users": [
+    {
+      "user": "u",
+      "server": "d1.dev"
+    },
+    {
+      "user": "u2",
+      "server": "d2.dev"
+    },
+    {
+      "user": "u3",
+      "server": "d3.dev"
+    }
+  ],
+  "days_to_keep": 7,
+  "backup_server": "backup.dev"
+}

metadata

@@ -0,0 +1,139 @@
+--- !ruby/object:Gem::Specification 
+name: dreamback
+version: !ruby/object:Gem::Version 
+  hash: 29
+  prerelease: 
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Paul R Alexander
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2012-05-22 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: json
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: net-sftp
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: cronedit
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: commander
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id004
+description: The easiest, cheapest way to back up your dreamhost accounts
+email: 
+- palexander@stanford.edu
+executables: 
+- dreamback
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- .rbenv-version
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- bin/dreamback
+- dreamback.gemspec
+- lib/dreamback.rb
+- lib/dreamback/backup.rb
+- lib/dreamback/base.rb
+- lib/dreamback/exclusions.txt
+- lib/dreamback/initializer.rb
+- lib/dreamback/version.rb
+- test/dreamback_test.rb
+- test/mock/settings.json
+has_rdoc: true
+homepage: https://github.com/palexander/dreamback
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.6.2
+signing_key: 
+specification_version: 3
+summary: Dreamback is the easiest way to automate your backups on dreamhost. Dreamhost does not guarantee their backups of your users (though they've saved me with backups before), so it's best to run backups yourself.
+test_files: 
+- test/dreamback_test.rb
+- test/mock/settings.json