mclaunch 0.0.1

data/.gitignore

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

data/Gemfile

@@ -0,0 +1,8 @@
+source 'https://rubygems.org'
+
+#Required Gems
+gem "progressbar"
+gem "logrotate"
+
+# Specify your gem's dependencies in mclaunch.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2012 odie
+
+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,30 @@
+# Mclaunch
+
+mclaunch is a launcher for a craftbukkit server, that runs the
+craftbukkit server in either a tmux or a GNU screen session.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'mclaunch'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install mclaunch
+
+## Usage
+
+type "mclaunch --help" in a terminal for help
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

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

data/bin/mclaunch

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

data/lib/mclaunch/commands.rb

@@ -0,0 +1,155 @@
+module Mclaunch
+  # Commands to issue on minecraft server
+
+  class Commands
+    def initialize(runtime=nil, options=nil, tools=nil)
+      @runtime = runtime
+      @options = options
+      @tools = tools
+      @quiet = @options[:quiet]
+      @debug = @options[:debug]
+    end #end initialize
+
+    #setter for @runtime
+    def set_runtime(runtime)
+      @runtime = runtime
+    end #end set_runtime(runtime)
+
+    #setter for @options
+    def set_options(options)
+      @options = options
+    end #end set_options(options)
+
+    #Reload command
+    def reload
+      puts "sending reload command to server" unless @quiet
+      @runtime.send_command("reload")
+    end #end reload
+
+    #save-on command
+    def save_on
+      puts "sending save-on command to server" unless @quiet
+      @runtime.send_command("save-on")
+    end #end save_on
+
+    #save-off command
+    def save_off
+      puts "sending save-off command to server" unless @quiet
+      @runtime.send_command("save-off")
+    end #end save_off
+
+    #save-all command
+    def save_all
+      puts "sending save-all command to server" unless @quiet
+      @runtime.send_command("save-all")
+    end #end save_all
+
+    #defaultgamemode command
+    def change_gamemode(mode)
+      raise "\n  False command: #{mode}\n\n  Use:\n    0 or survival\n    1 or creative\n    2 or adventure" unless mode =~ /^([0-2]|(survival|creative|adventure))$/
+      puts "changing gamemode to \"#{mode}\"" unless @quiet
+      @runtime.send_command("defaultgamemode #{mode.to_i}") if mode =~ /^[0-2]$/
+      @runtime.send_command("defaultgamemode #{mode.to_s}") if mode =~ /^(survival|creative|adventure)$/
+    end #end change_gamemode(mode)
+
+    #difficulty command
+    def change_difficulty(difficulty)
+      raise "\n  Command only available with minecraft-server.jar" unless @options[:server_executable].eql? "minecraft-server.jar"
+      raise "\n  False command: #{difficulty}\n\n  Use:\n    0 or peaceful\n    1 or easy\n    2 or normal\n    3 or hard" unless difficulty =~ /^([0-3]|(peaceful|easy|normal|hard))$/
+      puts "changing difficulty to \"#{difficulty}\"" unless @quiet
+      @runtime.send_command("difficulty #{difficulty.to_i}") if difficulty =~ /^[0-3]$/
+      @runtime.send_command("difficulty #{difficulty.to_s}") if difficulty =~ /^(peaceful|easy|normal|hard)i$/
+    end #end change_difficulty(difficulty)
+
+    #op command
+    def op(player)
+      cmd = "op #{player}"
+      online_mode = @tools.to_boolean(@runtime.get_server_properties['online-mode'])
+      is_player = @tools.is_minecraft_player?(player)
+      puts "adding \"#{player}\" to #{@options[:server_runtime_directory]}opts.txt" unless @quiet
+      if online_mode
+        @runtime.send_command(cmd) if is_player && @tools.is_op?(player)
+      else
+        @runtime.send_command(cmd)
+      end
+    end #end op(player)
+
+    #deop command
+    def deop(player)
+      puts "removing #{player} from #{@options[:server_runtime_directory]}opts.txt" unless @quiet
+      @runtime.send_command("deop #{player}") if @tools.is_op?(player)
+    end #end deop(player)
+
+    #kick player command
+    def kick_player(player)
+      puts "kicking #{player} from server" unless @quiet
+      @runtime.send_command("kick #{player}")
+    end #end kick_player(player, reason=nil)
+
+    #ban player command
+    def ban_player(player, reason=nil)
+      puts "banning #{player} from server" unless @quiet
+      reason_string = reason if reason.is_a?(String)
+      reason_string = @tools.array_to_string(reason) if reason.is_a?(Array)
+      @runtime.send_command("ban #{player} #{reason_string}")
+    end #end ban_player(player, reason=nil)
+
+    #ban ip command
+    def ban_ip(ip, reason=nil)
+      raise "This is not an IP address!" unless ip =~/^[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}/
+      puts "banning \"#{ip}\ from server" unless @quiet
+      reason_string = reason if reason.is_a?(String)
+      reason_string = @tools.array_to_string(reason) if reason.is_a?(Array)
+      @runtime.send_command("ban-ip #{ip} #{reason_string}")
+    end #end ban_ip(ip, reason=nil)
+
+    #pardon player command
+    def pardon_player(player)
+      puts "removing ban for \"#{player}\"." unless @quiet
+      @runtime.send_command("pardon #{player}")
+    end #end pardon_player(player, reason=nil)
+
+    #pardon ip command
+    def pardon_ip(ip)
+      raise "This is not an IP address!" unless ip =~/^[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}/
+      puts "removing ban for \"#{ip}\"." unless @quiet
+      @runtime.send_command("pardon-ip #{ip}")
+    end #end pardon_ip(ip, reason=nil)
+
+    #whitelist <on|off|list> command
+    def whitelist(cmd)
+      raise "Available commands are: on, off, list" unless cmd =~ /^(on|off|list)$/
+      unless @quiet
+        puts "turning whitelist on." if cmd.eql?("on")
+        puts "turning whitelist off." if cmd.eql?("off")
+      end
+      @runtime.send_command("whitelist #{cmd}")
+    end #end whitelist(cmd)
+
+    #whitelist add command
+    def whitelist_add(player)
+      cmd = "whitelist add #{player}"
+      online_mode = @tools.to_boolean(@runtime.get_server_properties['online-mode'])
+      is_player = @tools.is_minecraft_player?(player)
+      puts "adding \"#{player}\" to whitelist" unless @quiet
+      if online_mode
+        @runtime.send_command(cmd) if is_player
+      else
+        @runtime.send_command(cmd)
+      end
+    end #end whitelist_add(player)
+
+    #whitelist remove command
+    def whitelist_remove(player)
+      cmd = "whitelist remove #{player}"
+      online_mode = @tools.to_boolean(@runtime.get_server_properties['online-mode'])
+      is_player = @tools.is_minecraft_player?(player)
+      puts "removing \"#{player}\" to whitelist" unless @quiet
+      if online_mode
+        @runtime.send_command(cmd) if is_player && @tools.is_op?(player)
+      else
+        @runtime.send_command(cmd)
+      end
+    end #end whitelist_remove(player)
+  end #end Commands
+end

data/lib/mclaunch/runtime.rb

@@ -0,0 +1,143 @@
+module Mclaunch
+  # Runtime Class for Minecraft server
+
+  extend self
+  require 'logrotate'
+  require 'mclaunch'
+
+  class Runtime
+    def initialize(options=nil)
+      @options = options
+      @start_cmd = "java -Xms#{@options[:server_min_heap_memory]} -Xmx#{@options[:server_max_heap_memory]} #{@options[:server_additional_options]} -jar #{@options[:server_executable]}"
+      @path = options[:server_runtime_directory]
+      @quiet = @options[:quiet]
+      @debug = @options[:debug]
+      @multiplexer = @options[:server_terminal_multiplexer]
+      @multiplexer_session_name = @options[:server_terminal_multiplexer_name]
+      @multiplexer_session = @options[:server_terminal_multiplexer_session]
+    end #end initialize
+
+    #setter for @options
+    def set_options(options)
+      @options = options
+    end #end set_options(options)
+
+    #Run server
+    def run
+      puts "starting server now." unless @quiet
+      if @debug
+        puts "Command: #{@start_cmd}"
+        puts "Multiplexer: #{@multiplexer}"
+      end
+      Dir.chdir(@path)
+      create_tmux_session(@multiplexer_session_name)
+      start
+      sleep 1
+      if is_running?
+        puts "server is running now." unless @quiet
+      else
+          run
+      end
+    end #end run
+
+    #start server
+    def start
+      send_command(@start_cmd)
+    end #end start
+
+    #stop server
+    def stop
+      send_command("stop")
+      sleep 5
+    end #end stop
+
+    #halt
+    def halt
+      puts "halting server now." unless @quiet
+      stop
+      log_rotate
+      kill_tmux_session(@multiplexer_session_name)
+      puts "server haltet." unless @quiet
+    end #end halt
+
+    def restart
+      puts "restarting server now." unless @quiet
+      stop
+      start
+      if is_running?
+        puts "server restart complete" unless @quiet
+      else
+        run
+      end
+    end
+
+    #check is server is running
+    def is_running?
+      puts "check if server is running" if @debug
+      return true if `ps ax | grep -v grep | egrep "(minecraft|craftbukkit).jar" | wc -l`.to_i > 0
+    end #end is_running?
+
+    #Send a command to a running server
+    def send_command(cmd)
+      puts "sending \"#{cmd}\" to #{@multiplexer} session \"#{@multiplexer_session_name}\"" if @debug
+      `tmux -S #{@multiplexer_session} send -t #{@multiplexer_session_name} "#{cmd}" ENTER` if @multiplexer.eql?("tmux")
+      `screen -p 0 -S #{@multiplexer_session_name} -X eval 'stuff \"#{cmd}\"'\15` if @multiplexer.eql?("screen")
+    end #end send_command(cmd)
+
+    #Send a chat message as a server say command
+    def send_message(msg)
+      msg = "say #{msg}"
+      puts "sending \"#{msg}\" as server chat message" if @debug
+      send_command(msg)
+    end #end send_message(msg)
+
+    #Create a tmux session for the server to run in
+    def create_tmux_session(name)
+      puts "connecting to or creating a new #{@multiplexer} session now" if @debug
+      `tmux -S #{@multiplexer_session} has-session -t #{name} > /dev/null 2>&1 || tmux -S #{@multiplexer_session} new-session -s #{name} -d` if @multiplexer.eql?("tmux")
+      `ps ax | grep -v grep | grep SCREEN | grep craftbukkit 2>&1 || screen -dmS #{name}` if @multiplexer.eql?("screen")
+      puts "multiplexer session should be started now" if @debug
+      sleep 0.1
+      File.chmod(01000, @multiplexer_session) if @Multiplexer.eql?("tmux")
+    end #end create_tmux_session(name)
+
+    #Kill a tmux session
+    def kill_tmux_session(name)
+      puts "killing #{@multiplexer} sessinon now" if @debug
+      case @multiplexer
+      when "screen"
+        send_command("exit") unless is_running?
+      when "tmux"
+        `tmux -S #{@multiplexer_session} kill-session -t #{@multiplexer_session_name}`
+      end
+      halt if is_running?
+    end #end kill_tmux_session(name)
+
+    #Rotate the server log file
+    def log_rotate
+      puts "Rotating logfile now" if @debug
+      options = {
+        :gzip => true,
+        :count => 5,
+      }
+      LogRotate.rotate_file("/home/odie/bukkit/server/server.log", options)
+    end #end log_rotate
+
+    #Get server.properties file from server runtime directory
+    def get_server_properties
+      props = Hash[File.read("#{@options[:server_runtime_directory]}server.properties").split("\n").map{|i|i.split('=') unless i =~ /^#.*$/}]
+      if @debug
+        puts "---"
+        puts "Server properties: "
+        puts
+        props.each do |k,v|
+          puts "\t#{k}=#{v}"
+        end
+        puts "---"
+        puts
+      end
+      props
+    end #end get_server_properties
+
+  end #end Runtime
+end

data/lib/mclaunch/tools.rb

@@ -0,0 +1,323 @@
+module Mclaunch
+  require 'net/http'
+  require 'net/https'
+  require 'rexml/document'
+  require 'open-uri'
+  require 'progressbar'
+  require 'date'
+
+  class Tools
+    def initialize(runtime, options)
+      @runtime = runtime
+      @options = options
+      @server_properties = @runtime.get_server_properties
+      @versions = {}
+      @debug = @options[:debug]
+      @quiet = @options[:quiet]
+      @xml_document = nil
+      @craftbukkit_version_regex = /^[1-9]\.[0-9]\.[0-9]-R[0-9]\.[0-9]$/
+      @commands = nil
+    end #end initialize
+
+    #Method desctiption
+    def commands(commands=nil)
+      @commands = commands
+      @commands unless @commands
+    end #end commands(commands=nil)
+
+    #Check online if Player name is a valid minecraft username if server is in online mode
+    def is_minecraft_player?(player)
+      if to_boolean(@server_properties['online-mode']) == true
+        uri = URI.parse("https://minecraft.net/haspaid.jsp?user=#{player}")
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = true
+        http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+        request = Net::HTTP::Get.new(uri.request_uri)
+        response = http.request(request)
+        to_boolean response.body
+      end
+    end #end is_minecraft_player?(player, cmd)
+
+    #check if player is in ops.txt
+    def is_op?(player)
+      puts "checking if \"#{player}\" is op." if @debug
+      ops = File.new("#{@options[:server_runtime_directory]}ops.txt", "r")
+      op = false
+      ops.each_line do |l|
+        op = true if l.gsub("\n", "").eql?(player)
+      end
+      op
+    end #end is_op?
+
+    def is_symlink_or_file(path)
+      File.exist?(path) || File.symlink?(path)
+    end #end is_symlink_or_file(path)
+
+    #Convert String to Boolean
+    def to_boolean(s)
+      s.eql?"true"
+    end #end to_boolean(s)
+
+    #Convert a array into a String.
+    def array_to_string(array, delimiter=" ")
+      tmp = ""
+      array.each do |s|
+        tmp += s+delimiter
+      end
+      tmp
+    end #end array_to_string(array, delimiter=" ")
+
+    def get_worlds
+      worlds = {}
+      dir = Dir.new(@options[:server_world_directory])
+      dir.each do |world|
+        unless world =~ /^(\.|\.\.)$/
+          ramdisk = false
+          ramdisk = true if File.exists?("#{@options[:server_world_directory]}#{world}/ramdisk")
+          worlds[world] = ramdisk
+          if @debug
+            puts "  world: #{world} runs from ramdisk" if ramdisk
+            puts "  world: #{world} runs from disk" unless ramdisk
+          end
+        end
+      end #end dir.each
+      return worlds
+    end #end get_worlds
+
+    #Create world Symlinks
+    def worlds_create_symlinks
+      worlds = get_worlds
+      worlds.each do |world,ramdisk|
+        src = "#{@options[:server_world_directory]}#{world}"
+        src = "#{@options[:server_ramdisk_directory]}#{world}" if ramdisk
+        dst = "#{@options[:server_runtime_directory]}#{world}"
+        File.unlink(dst) if File.symlink?(dst)
+        File.symlink(src,dst)
+        puts "Symlink created for: #{world}" unless @quiet
+        puts "Source: #{src}\nDestination: #{dst}" if @debug
+      end
+    end #end worlds_create_symlinks
+
+    def world_ramdisk_state(world_name)
+      worlds = get_worlds
+      world_exists = false
+      world_already_on_ramdisk = false
+      worlds.each do |world,ramdisk|
+        if world.eql? world_name
+          world_exists = true
+          world_already_on_ramdisk = ramdisk
+        end
+      end
+      if world_name
+        if world_exists
+          if world_already_on_ramdisk
+            puts "\"#{world_name}\" will run from harddisk on next server start" unless @quiet
+            File.delete("#{@options[:server_world_directory]}#{world_name}/ramdisk")
+          else
+            puts "\"#{world_name}\" will run from ramdisk on next server start" unless @quiet
+            File.open("#{@options[:server_world_directory]}#{world_name}/ramdisk", "w")
+          end #end if world_already_on_ramdisk
+        else
+          puts "\"#{world_name}\" does not exist in world folder!"
+        end #end if world_exists
+      end #end if world_name
+    end #end world_ramdisk_state(world_name)
+
+    def worlds_to_ramdisk
+      worlds = get_worlds
+      worlds.each do |world,ramdisk|
+        if ramdisk
+          print "copy #{world} to ramdisk... " unless @quiet
+          `rsync -rt --exclude 'ramdisk' #{@options[:server_world_directory]}#{world}/ #{@options[:server_ramdisk_directory]}#{world}`
+          puts "ok" unless @quiet
+        end #end if ramdisk
+      end #worlds.each
+    end #end to_ramdisk
+
+    def worlds_to_disk
+      worlds = get_worlds()
+      ramdisk_worlds = Dir.open("#{@options[:server_ramdisk_directory]}")
+      ramdisk_worlds.each do |world|
+        if worlds.key?(world)
+          if worlds[world]
+            print "copy #{world} to harddisk... " unless @quiet
+            `rsync -rt --exclude 'ramdisk' #{@options[:server_ramdisk_directory]}#{world}/ #{@options[:server_world_directory]}#{world}`
+            puts "ok" unless @quiet
+          end
+        end #end if ramdisk
+      end #worlds.each
+    end #end to_ramdisk
+
+    #Get a hash of the locally available server versions
+    def get_local_server_versions
+      dir = Dir.new(@options[:server_jar_directory])
+      dir.sort.each do |f|
+        @versions[f.gsub(/^craftbukkit-|\.jar$/, "")] = "#{@options[:server_jar_directory]}#{f}" unless f =~ /^(\.\.|\.)$/
+      end
+      @versions
+    end #end get_local_server_versions
+
+    #Print locally available server versions to stdout
+    def print_local_server_versions
+      get_local_server_versions.each do |k,v|
+        puts "#{k}, #{v}"
+      end
+    end #end print_local_server_versions
+
+    #Check if given version is available locally
+    def local_version_available?(channel, version, build_number)
+      true if get_local_server_versions.has_key?("#{channel}-#{version}-#{build_number}")
+    end #end local_version_available?(version)
+
+    #Get an xml Document from the given url
+    def get_xml_document(url)
+        xml_data = Net::HTTP.get_response(URI.parse(url))
+        raise "Search for xml document data returned HTTP Error 404\n\nMaybe the version you entered does not exist." if xml_data.is_a?(Net::HTTPNotFound)
+        @xml_document = REXML::Document.new(xml_data.body)
+        raise "xml document empty" unless @xml_document
+    end #end get_xml_document(url)
+
+    #Get xml data from craftbukkit site as hash
+    def get_xml_first_path(url, path)
+      get_xml_document(url)
+      REXML::XPath.first(@xml_document, path).text
+    end #end get_xml_data(url)
+
+    #Get the latest build number for given version that was not broken
+    def get_latest_build_number(version, page=1)
+      url = "http://dl.bukkit.org/api/1.0/downloads/projects/craftbukkit/artifacts/?_accept=application%2Fxml&limit=20&page=#{page}"
+      build_number = nil
+      get_xml_document(url)
+      max_page = REXML::XPath.first(@xml_document, "//pages").text
+      REXML::XPath.each(@xml_document, "/root/results/list-item") do |element|
+        vers = element.text "version"
+        build_nr = element.text "build_number"
+        next if element.text("is_broken") =~ /^[Tt][Rr][Uu][Ee]$/
+        build_number = build_nr if version.eql? vers
+      end
+      if build_number.to_i > 0
+        return build_number
+      else
+        get_latest_build_number(version, page + 1) if page <= max_page.to_i
+      end
+    end #end get_latest_build_number(version)
+
+    #Return the link for the latest version of craftbukkit
+    def get_download_link(version)
+      prefix = "http://dl.bukkit.org"
+      url = "#{prefix}/api/1.0/downloads/projects/craftbukkit/artifacts/#{version}/?_accept=application%2Fxml" if version =~ /^(rb|beta|dev)$/
+      url = "#{prefix}/api/1.0/downloads/projects/craftbukkit/view/build-#{version}/?_accept=application%2Fxml" if version =~ /^[0-9][0-9][0-9][0-9]$/
+      url = "#{prefix}/api/1.0/downloads/projects/craftbukkit/view/build-#{get_latest_build_number(version)}/?_accept=application%2Fxml" if version =~ @craftbukkit_version_regex
+      raise "Thist is no Craftbukkit Version." unless url
+      {
+        :link => "#{prefix}#{get_xml_first_path(url, '//file/url')}",
+        :checksum => get_xml_first_path(url, "//file/checksum_md5"),
+        :version => get_xml_first_path(url, "//version"),
+        :build_number => get_xml_first_path(url, "//build_number"),
+        :channel => get_xml_first_path(url, "//channel/slug"),
+      }
+    end #end get_latest_download_link
+
+    #Download the latest server executable
+    def download_server_executable(version)
+      link = get_download_link(version)
+      url = link[:link]
+      md5 = link[:checksum]
+      version = link[:version]
+      build_number = link[:build_number]
+      channel = link[:channel]
+      target = "#{@options[:server_jar_directory]}craftbukkit-#{channel}-#{version}-#{build_number}.jar"
+
+      #Debug output
+      if @debug
+        puts "[#{version}]"
+        puts "  link:\t\t#{url}"
+        puts "  md5:\t\t#{md5}"
+        puts "  taret:\t#{target}"
+        puts "  build_nr:\t#{build_number}"
+        puts "  channel:\t#{channel}"
+      end
+
+      if local_version_available? channel, version, build_number
+        puts "local version available. Will symlink local version to server runtime directory." if @debug
+      else
+        puts "local version not available. Will download new version and put symlink to it in server runtime directory." if @debug
+        download_file(url, target)
+      end
+      set_server_exe_symlink(target)
+    end #end download_latest_server_executable
+
+    #Change server version manually
+    def server_change_version(version)
+      link = get_download_link(version)
+      raise "This is no Craftbukkit Version!" unless version =~ /^(#{@craftbukkit_version_regex}|[0-9]{4})$/
+      if local_version_available?(link[:channel], link[:version], link[:build_number])
+        filename = "craftbukkit-#{version}.jar"
+        set_server_exe_symlink filename
+      else
+        download_server_executable(version)
+      end
+    end #end server_change_version(version)
+
+    #Download url to path
+    def download_file(url, path)
+      puts "downloading file from: \"#{url}\"" unless @quiet
+      url = URI(url)
+      location = URI(Net::HTTP.get_response(url)['location'])
+      Net::HTTP.start(location.host, location.port) do |http|
+        unless File.exist?(path)
+          f = open(path, 'wb')
+          begin
+            downloadedSize = 0
+            http.request_get(location.request_uri) do |resp|
+              progressBar = ProgressBar.new("Downloading", 100)
+              size = resp.content_length
+              resp.read_body do |segment|
+                downloadedSize += segment.length
+                if(downloadedSize != 0)
+                  percent = (downloadedSize * 100 / size)
+                  progressBar.set(percent)
+                end
+                f.write(segment)
+              end #end resp.read_body
+              progressBar.finish
+            end #end http.request_get
+          ensure
+            f.close()
+          end #end begin
+        end #end Net::HTTP.start
+      end
+    end #end download_file(url, path)
+
+    def set_server_exe_symlink(file)
+      current_file = "#{@options[:server_runtime_directory]}#{@options[:server_executable]}"
+      was_running = false
+      if @runtime.is_running?
+        was_running = true
+        @runtime.stop
+      end
+      puts "symlinking #{file} to #{current_file}"
+      File.unlink(current_file) if is_symlink_or_file(current_file)
+      File.symlink(file,current_file)
+      @runtime.start if was_running
+    end #end set_server_exe_symlink(file)
+
+    #Create a world backup with rsync
+    def world_backup_create
+      puts "Creating world folder backup now." unless @quiet
+      @commands.save_off
+      @commands.save_all
+      sleep 1
+      `rsync -a --delete-after #{@options[:server_world_directory]} #{@options[:server_backup_directory]}worlds/latest > #{@options[:server_backup_directory]}worlds/latest/rsync.log`
+      @commands.save_on
+      now = DateTime.now.strftime("%Y-%m-%d-%H:%M:%S")
+      `cp -al #{@options[:server_backup_directory]}worlds/latest #{@options[:server_backup_directory]}worlds/#{now}`
+    end #end world_backup create
+
+    #Delete world backups which are older than a month
+    def world_backup_delete
+      puts "Deleting old backups" unless @quiet
+      `find #{@options[:server_backup_directory]} -mindepth 1 -maxdepth 1  -not -newermt '1 month ago' -exec rm -rf {} \\;`
+    end #end world_backup_delete
+  end #end class Tools
+end #end module Mclaunch

data/lib/mclaunch/version.rb

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

data/lib/mclaunch.rb

@@ -0,0 +1,347 @@
+module Mclaunch
+  require "mclaunch/version"
+  require "mclaunch/runtime"
+  require "mclaunch/commands"
+  require "mclaunch/tools"
+  require 'optparse'
+  require 'yaml'
+
+  default_options = {
+    :server_executable => "craftbukkit.jar",
+    :server_runtime_directory => "#{ENV["HOME"]}/bukkit/server/",
+    :server_world_directory => "#{ENV["HOME"]}/bukkit/worlds/",
+    :server_jar_directory => "#{ENV["HOME"]}/bukkit/jars/",
+    :server_backup_directory => "#{ENV["HOME"]}/bukkit/backup/",
+    :server_ramdisk_directory => "#{ENV["HOME"]}/bukkit/ramdisk/",
+    :server_min_heap_memory => "512M",
+    :server_max_heap_memory => "1024M",
+    :server_additional_options => nil,
+    :server_terminal_multiplexer => "tmux",
+    :server_terminal_multiplexer_name => "craftbukkit",
+    :server_terminal_multiplexer_session => "/tmp/craftbukkit",
+  }
+  @options = {
+    :debug => false,
+    :quiet => false,
+    :config_file => nil,
+    :server_management => {
+     :list_versions => false,
+     :update_to_latest => nil,
+     :server_change_version => nil,
+     :world_to_ramdisk => nil,
+     :world_to_disk => nil,
+     :worlds_create_symlinks => nil,
+    },
+    :server_commands => {
+      :reload => false,
+      :save_on => false,
+      :save_off => false,
+      :save_all => false,
+      :gamemode => nil,
+      :difficulty => nil,
+      :op => nil,
+      :deop => nil,
+      :kick => nil,
+      :kick_player => nil,
+      :kick_ip => nil,
+      :pardon_player => nil,
+      :pardon_ip => nil,
+      :whitelist_on => false,
+      :whitelist_off => false,
+      :whitelist_add => nil,
+      :whitelist_remove => nil,
+    }
+  }
+  @options.merge! default_options
+
+
+  opt_parser = OptionParser.new do |opts|
+
+    #Write Standard config file if it does't exist
+
+    @config_file = "#{@options[:server_runtime_directory]}mclaunch.properties" unless @options[:config_file]
+    @config_file = @options[:config_file] if @options[:config_file]
+    if File.exists?(@config_file) == false
+      File.open(@config_file, "w") {|f| f.write(default_options.to_yaml)}
+    end
+
+
+    opts.banner  = "  Usage:\t#{__FILE__.gsub(/(^\/.*\/|\.rb)/, "")} <options> start/stop/restart\n"
+    opts.separator ""
+    opts.separator "  Avalable options are:\n"
+    opts.separator ""
+
+    opts.separator "  Game management:"
+
+    opts.on('--reload', "reload the minecraft server") do
+      @options[:server_commands][:reload] = true
+    end #end opts.on
+
+    opts.on('--save-on', "turn the save mode on") do
+      @options[:server_commands][:save_on] = true
+    end #end opts.on
+
+    opts.on('--save-off', "turn the save mode off") do
+      @options[:server_commands][:save_off] = true
+    end #end opts.on
+
+    opts.on('--save-all', "save the current world state") do
+      @options[:server_commands][:save_all] = true
+    end #end opts.on
+
+    opts.on('--gamemode GAMEMODE', String, "change the current gamemode to GAMEMODE") do |arg|
+      @options[:server_commands][:gamemode] = arg
+    end #end opts.on
+
+    opts.on('--difficulty DIFFICULTY', String, "change the current difficulty to DIFFICULTY") do |arg|
+      @options[:server_commands][:difficulty] = arg
+    end #end opts.on
+
+    opts.on('--op-player PLAYER', String, "grant op status on PLAYER") do |arg|
+      @options[:server_commands][:op] = arg
+    end #end opts.on
+
+    opts.on('--deop-player PLAYER', String, "revoke op status on Player") do |arg|
+      @options[:server_commands][:deop] = arg
+    end #end opts.on
+
+    opts.on('--ban-player PLAYER [REASON]', String, "ban PLAYER") do |arg|
+      @options[:server_commands][:ban_player] = arg
+    end #end opts.on
+
+    opts.on('--ban-ip 11.22.33.44 [REASON]', String, "ban IP") do |arg|
+      @options[:server_commands][:ban_ip] = arg
+    end #end opts.on
+
+    opts.on('--pardon-player PLAYER', String, "pardon PLAYER") do |arg|
+      @options[:server_commands][:pardon_player] = arg
+    end #end opts.on
+
+    opts.on('--pardon-ip 11.22.33.44', String, "pardon IP") do |arg|
+      @options[:server_commands][:pardon_ip] = arg
+    end #end opts.on
+
+    opts.on('--whitelist-add PLAYER', String, "add PLAYER to whitelist") do |arg|
+      @options[:server_commands][:whitelist_add] = arg
+    end #end opts.on
+
+    opts.on('--whitelist-remove PLAYER', String, "remove PLAYER from whitelist") do |arg|
+      @options[:server_commands][:whitelist_remove] = arg
+    end #end opts.on
+
+    opts.on('--whitelist-on', "turn the whitelist on") do
+      @options[:server_commands][:whitelist_on] = true
+    end #end opts.on
+
+    opts.on('--whitelist-off', "turn the whitelist off") do
+      @options[:server_commands][:whitelist_off] = true
+    end #end opts.on
+
+    opts.separator ""
+    opts.separator "  Server Settings:"
+
+    opts.on('-m', '--minimal-mem 512M', "set the minimal memory to use in format \"512M\"") do |arg|
+      @options[:server_min_heap_memory] = arg
+    end
+
+    opts.on('-M', '--maximal-mem 1G', "set the maximal memory to use in format \"1024M\"") do |arg|
+      @options[:server_max_heap_memory] = arg
+    end
+
+    opts.on('--server-executable JAR', String, "set the JAR to use for current session") do |arg|
+      @options[:server_executable] = arg
+    end
+
+    opts.on('--server-directory DIR', String, "set the directory to user to DIR") do |arg|
+      @options[:server_runtime_directory] = arg
+    end
+
+    opts.on('--jar-directory DIR', String, "set the jar directory to use to DIR") do |arg|
+      @options[:server_jar_directory] = arg
+    end
+
+    opts.on('--world-directory DIR', String, "set the world directory to use to DIR") do |arg|
+      @options[:server_world_directory] = arg
+    end
+
+    opts.on('--backup-directory DIR', String, "set the backup directory to use to DIR") do |arg|
+      @options[:server_backup_directory] = arg
+    end
+
+    opts.separator ""
+    opts.separator "  Server Magagement:"
+
+    opts.on('-l', '--list-versions', "list locally available Server versions") do
+      @options[:server_management][:list_versions] = true
+    end
+
+    opts.on('--update VERSION', "update to latest craftbukkit version, where version may be \"rb, beta or dev\"") do |arg|
+      @options[:server_management][:update_to_latest] = arg
+    end
+
+    opts.on('--server-version VERSION', "Set server version to Version") do |arg|
+      @options[:server_management][:server_change_version] = arg
+    end
+
+    opts.separator ""
+    opts.separator "  World Management:"
+
+    opts.on('--world-to-ramdisk WORLD', "Set ramdisk flag for WORLD") do |arg|
+      @options[:server_management][:world_to_disk] = arg
+    end
+
+    opts.on('--world-to-disk WORLD', "Remove ramdisk flag from WORLD") do |arg|
+      @options[:server_management][:world_to_ramdisk] = arg
+    end
+
+    opts.on('--worlds-symlink', "Symlink all worlds in the worlds directory to runtime directory")do |arg|
+      @options[:server_management][:worlds_create_symlinks] = arg
+    end
+
+    opts.on('--world-backup-create', "Create a Backup from world directory to backup directory") do
+      @options[:server_management][:world_backup_create] = true
+    end
+
+    opts.on('--world-backup-delete', "Delete 1 month old backupa from backup directory") do
+      @options[:server_management][:world_backup_delete] = true
+    end
+
+    opts.separator ""
+    opts.separator "  Misc Options:"
+
+    opts.on('-q', '--quiet', "turn off all output") do
+      @options[:quiet] = true
+    end #end opts.on
+
+    opts.on('-d', '--debug', "turn debug output on") do
+      @options[:debug] = true
+    end #end opts.on
+
+    opts.on("-h", "--help", "Show this message") do
+      puts opts
+    end # end opts.on_tail
+
+    opts.separator ""
+    opts.separator ""
+    opts.separator "  Usage Examples:"
+    opts.separator ""
+    opts.separator "  Start, Stop, Restart"
+    opts.separator "  To start the craftbukkit server use:"
+    opts.separator "    #{__FILE__.gsub(/(^\/.*\/|\.rb)/, "")} <options> start"
+    opts.separator "  To stop the craftbukkit server use:"
+    opts.separator "    #{__FILE__.gsub(/(^\/.*\/|\.rb)/, "")} stop"
+    opts.separator "  To restart the craftbukkit server use:"
+    opts.separator "    #{__FILE__.gsub(/(^\/.*\/|\.rb)/, "")} <options> restart"
+    opts.separator ""
+    opts.separator "  Server Management:"
+    opts.separator "  kick player:"
+    opts.separator "    #{__FILE__.gsub(/(^\/.*\/|\.rb)/, "")} --kick-player notch"
+    opts.separator "  change gamemode:"
+    opts.separator "    #{__FILE__.gsub(/(^\/.*\/|\.rb)/, "")} --gamemode creative"
+    opts.separator ""
+
+
+  end
+
+  begin
+    @options.merge!(Hash[YAML::load(File.new(@config_file)).map { |k, v| @options[k] = v}])
+
+    opt_parser.parse!
+  rescue => exc
+    STDERR.puts "an error with the command line options occured:\n\t#{exc}"
+    STDERR.puts
+    STDERR.puts "For usage options use #{__FILE__.gsub(/^\/.*\//, "")} --help"
+    exit 1
+  end
+
+  begin
+    @runtime = Runtime.new(@options)
+    @tools = Tools.new(@runtime, @options)
+    @commands = Commands.new(@runtime, @options, @tools)
+    @tools.commands(@commands)
+    @craftbukkit_version_regex = /^[1-9]\.[0-9]\.[0-9]-R[0-9]\.[0-9]$/
+
+    @options[:server_management].each do |k,v|
+      case k
+      when :list_versions
+        @tools.print_local_server_versions if v
+      when :update_to_latest
+        @tools.download_server_executable(v) if v =~ /^(rb|beta|dev)$/
+      when :server_change_version
+        @tools.server_change_version(v) if v =~ /^(#{@craftbukkit_version_regex}|[0-9]{4})$/
+      when :world_to_ramdisk
+        @tools.world_ramdisk_state(v) if v
+      when :world_to_disk
+        @tools.world_ramdisk_state(v) if v
+      when :worlds_create_symlinks
+        @tools.worlds_create_symlinks if v
+      when :world_backup_create
+        @tools.world_backup_create if v
+      when :world_backup_delete
+        @tools.world_backup_delete if v
+      end
+    end
+    @options[:server_commands].each do |k,v|
+      case k
+      when :reload
+        @commands.reload if v
+      when :save_on
+        @commands.save_on if v
+      when :save_off
+        @commands.save_off if v
+      when :save_all
+        @commands.save_all if v
+      when :gamemode
+        @commands.change_gamemode(v) if v
+      when :difficulty
+        @commands.change_difficulty(v) if v
+      when :op
+        @commands.op(v) if v
+      when :deop
+        @commands.deop(v) if v
+      when :kick_player
+        @commands.kick_player(v) if v
+      when :kick_ip
+        @commands.kick_ip(v) if v
+      when :ban_player
+        @commands.ban_player(v, ARGV) if v
+      when :ban_ip
+        @commands.ban_ip(v, ARGV) if v
+      when :pardon_player
+        @commands.pardon_player(v) if v
+      when :pardon_ip
+        @commands.pardon_ip(v) if v
+      when :whitelist_on
+        @commands.whitelist("on") if v
+      when :whitelist_off
+        @commands.whitelist("off") if v
+      when :whitelist_add
+        @commands.whitelist_add(v) if v
+      when :whitelist_remove
+        @commands.whitelist_remove(v) if v
+      end
+    end
+  rescue => exc
+    STDERR.puts "An runtime error occured:\n\t#{exc.message}"
+    STDERR.puts
+    STDERR.puts "For usage options use #{__FILE__.gsub(/^\/.*\//, "")} --help"
+  end
+
+  begin
+    case ARGV[0]
+    when "start"
+      @tools.worlds_to_ramdisk
+      @runtime.run
+    when "stop"
+      @runtime.halt
+      @tools.worlds_to_disk
+    when "restart"
+      @tools.worlds_to_disk
+      @tools.worlds_to_ramdisk
+      @runtime.restart
+    end
+  rescue => exc
+    STDERR.puts exc.message
+  end
+end
+

data/mclaunch.gemspec

@@ -0,0 +1,19 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'mclaunch/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "mclaunch"
+  gem.version       = Mclaunch::VERSION
+  gem.authors       = ["odie"]
+  gem.email         = ["masterodie@gmail.com"]
+  gem.description   = "A craftbukkit server launcher"
+  gem.summary       = "A craftbukkit server launcher"
+  gem.homepage      = ""
+
+  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.require_paths = ["lib"]
+end

metadata

@@ -0,0 +1,58 @@
+--- !ruby/object:Gem::Specification
+name: mclaunch
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- odie
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-12-01 00:00:00.000000000 Z
+dependencies: []
+description: A craftbukkit server launcher
+email:
+- masterodie@gmail.com
+executables:
+- mclaunch
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/mclaunch
+- lib/mclaunch.rb
+- lib/mclaunch/commands.rb
+- lib/mclaunch/runtime.rb
+- lib/mclaunch/tools.rb
+- lib/mclaunch/version.rb
+- mclaunch.gemspec
+homepage: ''
+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: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: A craftbukkit server launcher
+test_files: []