mang_keeper 0.1.0

data/.gitignore

@@ -0,0 +1,5 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
+.mangkeeper/*

data/Gemfile

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

data/README.md

@@ -0,0 +1,4 @@
+MangKeeper
+==========
+
+mangkeeper -h

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/bin/mangkeeper

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+
+begin
+  require 'rubygems'
+rescue LoadError
+end
+
+require 'mang_keeper'
+
+MangKeeper.application.run

data/lib/mang_keeper.rb

@@ -0,0 +1,21 @@
+require "optparse"
+require "ostruct"
+require "active_support/inflector"
+require "json"
+
+require "mang_keeper/version"
+require "mang_keeper/helpers/dbhelpers"
+require "mang_keeper/helpers/helpers"
+require "mang_keeper/helpers/initcheckhelpers"
+require "mang_keeper/helpers/confighelpers"
+require "mang_keeper/updates"
+require "mang_keeper/updates/core"
+require "mang_keeper/updates/ytdb"
+require "mang_keeper/updates/core_mr"
+require "mang_keeper/updates/sd2"
+require "mang_keeper/updates/sd2_mr"
+require "mang_keeper/scenario"
+require "mang_keeper/storage"
+require "mang_keeper/config"
+require "mang_keeper/application"
+require "mang_keeper/initializer"

data/lib/mang_keeper/application.rb

@@ -0,0 +1,157 @@
+module MangKeeper  
+  class << self
+    def application
+      @application ||= Application.new
+    end
+    
+    def scenario
+      application.scenario
+    end
+  end
+  
+  class Application
+  
+    DEFAULT_STORAGE_DIR = ".mangkeeper"
+    DEFAULT_SCENARIO = "info"
+    
+    attr_accessor :skip_init_check
+    attr_reader :scenario
+    
+    def initialize
+      @skip_init_check = false
+    end
+    
+    def run
+      init
+      start_scenario
+    end
+    
+    def init
+      handle_options
+      load_storage
+      config
+      get_scenario_name
+      load_scenario
+    end
+
+    
+    def options
+      @options ||= OpenStruct.new
+    end
+    
+    def storage
+      @storage
+    end
+    
+    def config
+      @config ||= ConfigManager.new
+    end
+    
+    def initializer
+      @initializer = Initializer.new 
+    end
+    
+    def dry_run?
+      !!options.dryrun
+    end
+    
+    # A list of all the standard options, suitable for
+    # passing to OptionParser.
+    def standard_options
+      [
+        ['--dry-run', '-n', "Do a dry run without executing actions.",
+          lambda { |value| options.dryrun = true }
+        ],
+        ['--storedir',  '-d', "Specify mangkeeper internal storage directory",
+          lambda { |value| options.storagedir = value }
+        ],
+        ['--version', '-v', "Display the program version.",
+          lambda { |value|
+            puts "mangkeeper, version #{VERSION}"
+            exit
+          }
+        ],
+      ]
+    end
+
+    # Read and handle the command line options.
+    def handle_options
+      OptionParser.new do |opts|
+        opts.banner = "mangkeeper scenario {options}"
+        opts.separator ""
+        opts.separator "Options are ..."
+
+        opts.on_tail("-h", "--help", "-H", "Display this help message.") do
+          puts opts
+          exit
+        end
+
+        standard_options.each { |args| opts.on(*args) }
+      end.parse!
+    end
+    
+    private
+    
+    def load_storage
+      storage_dir = options.storagedir || DEFAULT_STORAGE_DIR
+      @storage = Storage.new(storage_dir)
+    end
+    
+    def get_scenario_name
+      @scenario_name = ARGV[0] || DEFAULT_SCENARIO
+    end
+    
+    def load_scenario
+      # Locate scenario
+      scenario_classname = "#{@scenario_name}_scenario".classify
+      
+      checklist = [
+        # Search scenario in the storage...
+        File.expand_path(File.join(storage.directory, 'scenarios')),
+        
+        # Search scenario in gem
+        'mang_keeper/scenarios',
+        
+        # In the current directory
+        '.',
+        './scenarios'      
+      ]
+      
+      # Search
+      @scenario_path = nil
+      checklist.each do |path|
+        file = build_scenario_path(path, scenario_classname.underscore)
+        
+        load_error = false
+        begin
+          require file
+        rescue LoadError
+          load_error = true
+        end
+        unless load_error
+          @scenario_path = file
+          break
+        end
+      end
+      raise "Scenario #{@scenario_name} not found!" unless @scenario_path
+      
+      @scenario = scenario_classname.constantize.new
+    end
+    
+    def build_scenario_path(path, scenario_name, ext = 'rb')
+      ext = ".#{ext}" unless ext =~ /^\./
+      File.join(path, "#{scenario_name}#{ext}")
+    end
+    
+    def start_scenario
+      unless @skip_init_check || MangKeeper.application.storage.init?
+        puts("You have to run \"mangkeeper init\" before you can use this command!")
+        exit
+      end
+      config.load_required      
+      @scenario.work
+    end
+  end
+  
+end
+

data/lib/mang_keeper/config.rb

@@ -0,0 +1,63 @@
+module MangKeeper
+  
+  class ConfigManager
+  
+    def initialize
+      @configs = {}
+      @required_configs_loaded = false
+    end
+    
+    def [](key)
+      @configs[key][:data]
+    end
+    
+    def require(config)
+      return false if @configs[config]
+      @configs[config] = { :loaded => false }
+      load_required if @required_configs_loaded
+    end
+    
+    def load_required
+      @configs.each do |config, info|
+        next if info[:loaded]
+        config_data = load(config, nil)
+        if config_data
+          info[:data] = config_data
+          info[:loaded] = true
+        else
+          raise "Required config was not found: #{config}"
+        end
+      end
+      @required_configs_loaded = true
+    end
+    
+    def dump(config)
+      save(config, self[config])
+    end
+    
+    def load(file, default = nil)
+      file = filename_check(file)
+      data = MangKeeper.application.storage.load(file, nil)
+      if data
+        JSON.parse(data)
+      else
+        default
+      end
+    end
+    
+    def save(file, data)
+      file = filename_check(file)
+      MangKeeper.application.storage.save(file, JSON.pretty_generate(data))
+    end
+    
+    private
+    
+    def filename_check(filename)
+      filename = filename.to_s
+      filename = filename + ".json" if File.extname(filename) == ""
+      filename
+    end
+    
+  end
+  
+end

data/lib/mang_keeper/helpers/confighelpers.rb

@@ -0,0 +1,13 @@
+module MangKeeper
+  
+  module ConfigHelpers
+    
+    module ClassMethods
+      def require_config(*args)
+        args.each { |conf| MangKeeper.application.config.require(conf) }         
+      end
+    end
+    
+  end
+  
+end

data/lib/mang_keeper/helpers/dbhelpers.rb

@@ -0,0 +1,51 @@
+module MangKeeper
+  
+  module DBHelpers
+  
+    def set_default_db database
+      @default_db = database
+    end
+    
+    def set_mysql_auth user, pass
+      @mysql_user, @mysql_pass = user, pass
+    end
+  
+    def upload_file_to_db filename, database = @default_db, options = {}
+      do_log = options[:log].nil? ? true : options[:log]
+      full_path_in_log = options[:full_path_in_log].nil? ? true : options[:full_path_in_log]
+      read_only_mode = options[:read_only_mode].nil? ? false : options[:read_only_mode]
+      
+      if do_log
+        log_filename = full_path_in_log ? filename : File.basename(filename)
+        puts "Uploading file: #{log_filename} to #{database}"
+      end
+      `mysql -B -u#{@mysql_user} -p#{@mysql_pass} -D#{database} < "#{filename}"` unless read_only_mode
+      # puts "Done" if do_log
+    end
+    
+    def recreate_db database
+      puts "Recreating DB: #{database}"
+      if os_windows?
+        `echo DROP DATABASE IF EXISTS #{database}; | mysql -B -u#{@mysql_user} -p#{@mysql_pass}`
+        `echo CREATE DATABASE IF NOT EXISTS #{database}; | mysql -B -u#{@mysql_user} -p#{@mysql_pass}`
+      else
+        `echo "DROP DATABASE IF EXISTS #{database};" | mysql -B -u#{@mysql_user} -p#{@mysql_pass}`
+        `echo "CREATE DATABASE IF NOT EXISTS #{database};" | mysql -B -u#{@mysql_user} -p#{@mysql_pass}`  
+      end
+    end
+
+
+    def upload_by_glob glob, options = {}
+      db = options[:db] || 'mangos'
+      exclude = options[:exclude] || []
+      filters = options[:filters] || []
+      Dir.glob(glob).each do |file|
+        next if exclude.member? File.basename(file)
+        next if filters.any? { |filter_proc| filter_proc && !filter_proc.call(file) }
+        upload_file_to_db file, db, { :read_only_mode => options[:read_only] }
+      end
+    end
+
+  end
+
+end

data/lib/mang_keeper/helpers/helpers.rb

@@ -0,0 +1,9 @@
+def os_windows?
+  !!(RUBY_PLATFORM =~ /mswin|mingw/)
+end
+
+class String
+  def to_i!(*args)
+    self.gsub(/[^0-9]/,'').to_i(*args)
+  end
+end

data/lib/mang_keeper/helpers/initcheckhelpers.rb

@@ -0,0 +1,11 @@
+module MangKeeper
+  
+  module InitCheckHelpers
+  
+    def skip_init_check!
+      MangKeeper.application.skip_init_check = true
+    end
+    
+  end
+
+end

data/lib/mang_keeper/init_generators/configs.rb

@@ -0,0 +1,22 @@
+config.save :mysql, {
+  user: "root",
+  pass: "",
+  default_db: "mangos",
+}
+
+config.save :sources_paths, {
+  mangos: "mangos",
+  scriptdev2: "mangos/src/bindings/ScriptDev2",
+  ytdb: "YTDB",
+}
+
+config.save :git_repos, {
+  mangos: "git://github.com/<user>/mangos.git",
+  scriptdev2: "git://github.com/<user>/scriptdev2.git",
+  ytdb: "git://github.com/<user>/YTDB.git",
+}
+
+config.save :load_sources, {
+  patch_scriptdev: true,
+  unpack_ytdb: true,
+}

data/lib/mang_keeper/initializer.rb

@@ -0,0 +1,53 @@
+module MangKeeper
+    
+  class Initializer
+    INIT_GENERATORS_DIR = File.join(File.dirname(__FILE__), "init_generators")
+
+    class InitContext
+      def initialize(filename)
+        @filename = filename
+      end
+      
+      def application
+        MangKeeper.application
+      end
+    
+      def config
+        application.config
+      end
+      
+      def storage
+        application.storage
+      end
+    end
+    
+    # This is an internal ruby constructor!!
+    def initialize
+      collect_init_scripts
+    end
+    
+    def run    
+      prepare_storage_dir
+      run_init_scripts
+    end
+    
+    private
+    
+    def collect_init_scripts
+      @init_scripts = Dir[File.join(INIT_GENERATORS_DIR, "*.rb")]
+    end
+    
+    def run_init_scripts
+      @init_scripts.each do |init_script|
+        InitContext.new(init_script).instance_eval(File.read(init_script))
+      end
+    end
+    
+    def prepare_storage_dir
+      Dir.mkdir(MangKeeper.application.storage.directory) unless File.directory?(MangKeeper.application.storage.directory)      
+    end
+
+  end
+
+end
+

data/lib/mang_keeper/scenario.rb

@@ -0,0 +1,26 @@
+module MangKeeper
+
+  module Scenario
+  
+    class Base
+      include DBHelpers
+      extend InitCheckHelpers
+      extend ConfigHelpers::ClassMethods
+      
+      def storage
+        MangKeeper.application.storage
+      end
+      
+      def config
+        MangKeeper.application.config
+      end
+      
+      def work
+        raise "Work must be defined for scenario!"
+      end
+      
+    end
+  
+  end  
+  
+end

data/lib/mang_keeper/scenarios/info_scenario.rb

@@ -0,0 +1,8 @@
+class InfoScenario < MangKeeper::Scenario::Base
+
+  def work
+    puts "MangKeeper"
+    puts "Use \"mangkeeper -h\" to get some hints"
+  end
+
+end

data/lib/mang_keeper/scenarios/init_scenario.rb

@@ -0,0 +1,13 @@
+class InitScenario < MangKeeper::Scenario::Base
+  skip_init_check!
+
+  def work
+    MangKeeper.application.initializer.run
+    puts <<-MSG.gsub(/^ */, "")
+      Initialized MangKeeper in #{storage.directory}
+
+      Now you should visit #{storage.directory} and do some configuration...
+    MSG
+  end
+
+end

data/lib/mang_keeper/storage.rb

@@ -0,0 +1,35 @@
+module MangKeeper
+
+  class Storage  
+    attr_reader :directory
+    
+    def initialize(dir)
+      @directory = dir
+      # warn "Storage directory #{directory} does not exist!" unless File.directory?(directory)      
+    end
+    
+    def save(file, data)
+      File.open(File.join(directory, file.to_s), "w") do |f|
+        f.write(data)
+      end
+    end
+    
+    # Load file with default value on error
+    def load(file, default = nil)  
+      load!(file)
+    rescue Errno::ENOENT
+      default
+    end
+    
+    # Load JSON file with exception
+    def load!(file)
+      File.read(File.join(directory, file.to_s))    
+    end
+    
+    # Is current storage directory initialized with mangkeeper?
+    def init?
+      File.directory?(directory) 
+    end
+  end
+
+end

data/lib/mang_keeper/updates.rb

@@ -0,0 +1,119 @@
+module MangKeeper
+
+  class UpdatesList
+  
+    def self.run &block
+      self.new.tap{ |list| list.instance_eval(&block) }
+    end
+  
+    def initialize
+      @list = []
+      @filters = {}
+    end
+    
+    # Allows tobind filter for specific update class
+    # Update will only be added if filter value is true
+    def filter(class_names, filter_code = nil, &block)
+      filter_code = block unless filter_code
+      raise ArgumentError, "You must pass a block or a proc as a second argument!" unless filter_code
+      class_names = [class_names] unless class_names.kind_of?(Array)
+      class_names.each do |class_name|
+        @filters[class_name] ||= []
+        @filters[class_name] << filter_code
+      end
+      self
+    end
+    
+    def add(update)
+      return false if @filters[update.class].any? { |filter_proc| filter_proc && !filter_proc.call(update) }      
+      add!(update)
+    end
+    
+    def add!(update)
+      @list << update
+    end
+    
+    def scan_by_glob(glob, updates_type)
+      Dir.glob(glob).each do |filename|
+        update = updates_type.build filename
+        add update if update
+      end
+      self
+    end
+    alias_method :[], :scan_by_glob
+    
+    def apply_all(read_only = false)
+      sorted_list.each do |update|
+        filename, database = update.upload_info
+        if read_only
+          puts "Will upload #{filename} to #{database} [#{update.class.name}]"
+        else          
+          MangKeeper.scenario.upload_file_to_db(filename, database)
+        end
+        update.applied!
+      end
+    end
+    
+    def latest_update
+      sorted_list.last
+    end
+    
+    def to_s
+      sorted_list.map(&:to_s).join("\n")
+    end
+    
+    private
+    
+    def sorted_list
+      @list.sort! do |a,b|
+        a, b = a.sort_data, b.sort_data
+        i = 0
+        i+=1 while a[i] == b[i] && (a[i+1] || b[i+1])
+        if a[i] && b[i]
+          a[i] <=> b[i]
+        else
+          a[i] ? 1 : -1
+        end
+      end
+      @list
+    end
+  end
+
+  class AbstractUpdateFile
+    attr_reader :filename, :database
+    
+    def self.build(filename)
+      self.new :filename => filename
+    end
+    
+    def initialize(options = {})
+      @filename = options[:filename]
+      @database = options[:database] # silently ignore if its nil and upload to default db
+      raise "Full filename must be supplied as :filename!" unless @filename      
+    end
+    
+    def upload_info
+      [self.filename, self.database]
+    end
+    
+    def sort_data
+      []
+    end
+    
+    def applied?
+      @applied
+    end
+    
+    def applied!
+      @applied = true
+    end
+    
+    def to_s
+      info
+    end
+    
+    def info
+      "[#{self.class.name}:#{filename}]"
+    end
+  end
+end

data/lib/mang_keeper/updates/core.rb

@@ -0,0 +1,27 @@
+module MangKeeper
+  class CoreUpdateFile < AbstractUpdateFile
+    APPLY_PRIORITY = 1
+    
+    def self.build filename
+      update = File.basename(filename, '.sql').split('_')
+      self.new :filename => filename, :database => update[2], :core_revision => update[0].to_i, :num => update[1].to_i
+    end
+    
+    attr_reader :core_revision, :num
+    def initialize options = {}
+      super
+      @core_revision = options[:core_revision]
+      @num = options[:num]
+      raise "Core revision must be supplied as :core_revision!" unless @core_revision      
+    end
+
+    def sort_data
+      [core_revision, APPLY_PRIORITY, num]
+    end
+    
+    def info
+      "Rev#{core_revision} #{super}"
+    end
+  end
+  
+end

data/lib/mang_keeper/updates/core_mr.rb

@@ -0,0 +1,26 @@
+module MangKeeper
+  class CoreMrUpdateFile < AbstractUpdateFile
+    APPLY_PRIORITY = 1
+    
+    def self.build filename
+      update = File.basename(filename, '.sql').split('_')
+      self.new :filename => filename, :database => update[1], :mr_revision => update[0].to_i!
+    end
+    
+    attr_reader :mr_revision
+    def initialize options = {}
+      super
+      @mr_revision = options[:mr_revision]
+      raise "MR revision must be supplied as :mr_revision!" unless @mr_revision      
+    end
+
+    def sort_data
+      [mr_revision, APPLY_PRIORITY]
+    end
+    
+    def info
+      "Rev#{mr_revision} #{super}"
+    end
+  end
+  
+end

data/lib/mang_keeper/updates/sd2.rb

@@ -0,0 +1,26 @@
+module MangKeeper
+  class Sd2UpdateFile < AbstractUpdateFile
+    APPLY_PRIORITY = 1
+    
+    def self.build filename
+      update = File.basename(filename, '.sql').split('_')
+      self.new :filename => filename, :database => update[1], :sd2_revision => update[0].to_i!
+    end
+    
+    attr_reader :sd2_revision
+    def initialize options = {}
+      super
+      @sd2_revision = options[:sd2_revision]
+      raise "SD2 revision must be supplied as :sd2_revision!" unless @sd2_revision      
+    end
+
+    def sort_data
+      [sd2_revision, APPLY_PRIORITY]
+    end
+    
+    def info
+      "Rev#{sd2_revision} #{super}"
+    end
+  end
+  
+end

data/lib/mang_keeper/updates/sd2_mr.rb

@@ -0,0 +1,26 @@
+module MangKeeper
+  class Sd2MrUpdateFile < AbstractUpdateFile
+    APPLY_PRIORITY = 1
+    
+    def self.build filename
+      update = File.basename(filename, '.sql').split('_')
+      self.new :filename => filename, :database => update[1], :mr_revision => update[0].to_i!
+    end
+    
+    attr_reader :mr_revision
+    def initialize options = {}
+      super
+      @mr_revision = options[:mr_revision]
+      raise "MR revision must be supplied as :mr_revision!" unless @mr_revision      
+    end
+
+    def sort_data
+      [mr_revision, APPLY_PRIORITY]
+    end
+    
+    def info
+      "Rev#{mr_revision} #{super}"
+    end
+  end
+  
+end

data/lib/mang_keeper/updates/ytdb.rb

@@ -0,0 +1,27 @@
+module MangKeeper
+  class YTDBUpdateFile < AbstractUpdateFile
+    APPLY_PRIORITY = 5
+    
+    def self.build filename
+      update = File.basename(filename, '.sql').split('_')
+      return if update[1] == 'corepatch' # skip all corepatches...      
+      self.new :filename => filename, :database => update[1], :core_revision => update[3].to_i!
+    end
+    
+    attr_reader :core_revision
+    def initialize options = {}
+      super
+      @core_revision = options[:core_revision]
+      raise "Core revision must be supplied as :core_revision!" unless @core_revision
+    end
+
+    def sort_data
+      [core_revision, APPLY_PRIORITY]
+    end
+    
+    def info
+      "Rev#{core_revision} #{super}"
+    end
+  end
+  
+end

data/lib/mang_keeper/version.rb

@@ -0,0 +1,3 @@
+module MangKeeper
+  VERSION = "0.1.0"
+end

data/mang_keeper.gemspec

@@ -0,0 +1,21 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "mang_keeper/version"
+
+Gem::Specification.new do |s|
+  s.name        = "mang_keeper"
+  s.version     = MangKeeper::VERSION
+  s.authors     = ["MOZGIII"]
+  s.email       = ["mike-n@narod.ru"]
+  s.homepage    = "http://github.com/MOZGIII/MaNGOS-Keeper"
+  s.summary     = %q{MaNGOS Keeper}
+  s.description = %q{Helps to maintain MaNGOS server.}
+
+  s.rubyforge_project = "mang_keeper"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+end

metadata

@@ -0,0 +1,72 @@
+--- !ruby/object:Gem::Specification
+name: mang_keeper
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- MOZGIII
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-09-10 00:00:00.000000000Z
+dependencies: []
+description: Helps to maintain MaNGOS server.
+email:
+- mike-n@narod.ru
+executables:
+- mangkeeper
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- README.md
+- Rakefile
+- bin/mangkeeper
+- lib/mang_keeper.rb
+- lib/mang_keeper/application.rb
+- lib/mang_keeper/config.rb
+- lib/mang_keeper/helpers/confighelpers.rb
+- lib/mang_keeper/helpers/dbhelpers.rb
+- lib/mang_keeper/helpers/helpers.rb
+- lib/mang_keeper/helpers/initcheckhelpers.rb
+- lib/mang_keeper/init_generators/configs.rb
+- lib/mang_keeper/initializer.rb
+- lib/mang_keeper/scenario.rb
+- lib/mang_keeper/scenarios/info_scenario.rb
+- lib/mang_keeper/scenarios/init_scenario.rb
+- lib/mang_keeper/storage.rb
+- lib/mang_keeper/updates.rb
+- lib/mang_keeper/updates/core.rb
+- lib/mang_keeper/updates/core_mr.rb
+- lib/mang_keeper/updates/sd2.rb
+- lib/mang_keeper/updates/sd2_mr.rb
+- lib/mang_keeper/updates/ytdb.rb
+- lib/mang_keeper/version.rb
+- mang_keeper.gemspec
+homepage: http://github.com/MOZGIII/MaNGOS-Keeper
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: mang_keeper
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: MaNGOS Keeper
+test_files: []