aws_minecraft 0.1.0

data/cfg/config.yml

@@ -0,0 +1,2 @@
+loglevel: INFO
+upload_path: /Users/hannibal/RubyProjects/aws_minecraft/drop

data/cfg/ec2_conf.json

@@ -0,0 +1,11 @@
+{
+    "dry_run": false,
+    "image_id": "ami-ea26ce85",
+    "key_name": "minecraft_keys",
+    "min_count": 1,
+    "max_count": 1,
+    "instance_type": "t2.nano",
+    "monitoring": {
+        "enabled": true
+    }
+}

data/cfg/instances.sql

@@ -0,0 +1,5 @@
+create table instances (
+      ip varchar(100),
+      id varchar(100),
+      PRIMARY KEY (id)
+);

data/cfg/sg_config.json

@@ -0,0 +1,20 @@
+{
+  "ip_permissions": [
+    {
+      "ip_protocol": "tcp",
+      "from_port": 22,
+      "to_port": 22,
+      "ip_ranges": [{
+        "cidr_ip": "0.0.0.0/0"
+      }]
+    },
+    {
+      "ip_protocol": "tcp",
+      "from_port": 25565,
+      "to_port": 25565,
+      "ip_ranges": [{
+        "cidr_ip": "0.0.0.0/0"
+      }]
+    }
+  ]
+}

data/cfg/user_data.sh

@@ -0,0 +1,21 @@
+#!/bin/bash
+yum update -y
+yum install git -y
+yum install libevent-devel -y
+yum install ncurses-devel -y
+yum install glibc-static -y
+yum install java-1.8.0-openjdk -y
+yum groupinstall "Development tools" -y
+cd ~
+wget https://github.com/downloads/libevent/libevent/libevent-2.0.21-stable.tar.gz
+tar xzvf libevent-2.0.21-stable.tar.gz
+cd libevent-2.0.21-stable
+./configure && make
+make install
+cd /home/ec2-user
+wget https://github.com/tmux/tmux/releases/download/2.2/tmux-2.2.tar.gz
+tar xfvz tmux-2.2.tar.gz
+cd tmux-2.2
+./configure && make
+cd /home/ec2-user
+chown -R ec2-user:ec2-user tmux-2.2

data/lib/aws_minecraft.rb

@@ -0,0 +1,117 @@
+require 'aws_minecraft/aws_helper'
+require 'aws_minecraft/db_helper'
+require 'aws_minecraft/upload_helper'
+require 'aws_minecraft/mine_config'
+require 'aws_minecraft/ssh_helper'
+require 'logger'
+
+module AWSMine
+  # Main class for AWS Minecraft
+  class AWSMine
+    MINECRAFT_SESSION_NAME = 'minecraft'.freeze
+    attr_accessor :aws_helper, :db_helper, :upload_helper, :ssh_helper
+    def initialize
+      @aws_helper = AWSHelper.new
+      @db_helper = DBHelper.new
+      @upload_helper = UploadHelper.new
+      @ssh_helper = SSHHelper.new
+      @logger = Logger.new(STDOUT)
+      @logger.level = Logger.const_get(MineConfig.new.loglevel)
+    end
+
+    def create_instance
+      if @db_helper.instance_exists?
+        ip, id = @db_helper.instance_details
+        @logger.info 'Instance already exists.'
+        state = @aws_helper.state(id)
+        @logger.info "State is: #{state}"
+        @logger.info "Public ip | id: #{ip} | #{id}"
+        return
+      end
+      ip, id = @aws_helper.create_ec2
+      @db_helper.store_instance(ip, id)
+    end
+
+    def start_instance
+      unless @db_helper.instance_exists?
+        @logger.info 'No instances found. Nothing to do.'
+        return
+      end
+      ip, id = @db_helper.instance_details
+      @logger.info("Starting instance #{ip} | #{id}.")
+      new_ip = @aws_helper.start_ec2(id)
+      @db_helper.update_instance(new_ip, id)
+    end
+
+    def stop_instance
+      unless @db_helper.instance_exists?
+        @logger.info 'No running instances found. Nothing to do.'
+        return
+      end
+      ip, id = @db_helper.instance_details
+      @logger.info("Stopping instance #{ip} | #{id}.")
+      @aws_helper.stop_ec2(id)
+    end
+
+    def terminate_instance
+      unless @db_helper.instance_exists?
+        @logger.info 'No running instances found. Nothing to do.'
+        return
+      end
+      @logger.info('WARNING! Terminating an instance will result in dataloss. Make ' \
+                   'sure everything is backed up. Do you want to continue? (Y/n):')
+      answer = $stdin.gets.chomp
+      return if answer == 'n'
+      ip, id = @db_helper.instance_details
+      @logger.info("Terminating instance #{ip} | #{id}.")
+      @aws_helper.terminate_ec2(id)
+      @db_helper.remove_instance
+    end
+
+    def start_server(name)
+      @logger.info("Starting server: #{name}.")
+      cmd = "cd /home/ec2-user/data && ../tmux-2.2/tmux new -d -s #{MINECRAFT_SESSION_NAME} " \
+            "'echo eula=true > eula.txt && java -jar #{name} nogui'"
+      @logger.info("Running command: '#{cmd}'")
+      remote_exec(cmd)
+      ip, = @db_helper.instance_details
+      @logger.info("Server URL is: #{ip}:25565")
+    end
+
+    def stop_server
+      @logger.info('Stopping server')
+      ip, = @db_helper.instance_details
+      @ssh_helper.stop_server(ip)
+    end
+
+    def attach_to_server
+      @logger.info("Attaching to server: #{MINECRAFT_SESSION_NAME}.")
+      ip, = @db_helper.instance_details
+      @ssh_helper.attach_to_server(ip)
+    end
+
+    def init_db
+      @logger.info 'Creating db.'
+      @db_helper.init_db
+      @logger.info 'Done.'
+    end
+
+    def upload_world
+    end
+
+    def upload_files
+      ip, = @db_helper.instance_details
+      @upload_helper.upload_files(ip)
+    end
+
+    def remote_exec(cmd)
+      ip, = @db_helper.instance_details
+      @ssh_helper.remote_exec(ip, cmd)
+    end
+
+    def ssh
+      ip, = @db_helper.instance_details
+      @ssh_helper.ssh(ip)
+    end
+  end
+end

data/lib/aws_minecraft/aws_helper.rb

@@ -0,0 +1,150 @@
+require 'json'
+require 'aws-sdk'
+require 'logger'
+require_relative 'mine_config'
+require 'base64'
+
+module AWSMine
+  # Main wrapper for AWS commands
+  class AWSHelper
+    attr_accessor :ec2_client, :ec2_resource
+    def initialize
+      # region: AWS_REGION
+      # Credentials are loaded from environment properties
+      config = MineConfig.new
+      credentials = Aws::SharedCredentials.new(profile_name: config.profile)
+      @ec2_client = Aws::EC2::Client.new(credentials: credentials)
+      @ec2_resource = Aws::EC2::Resource.new(client: @ec2_client)
+      @logger = Logger.new(STDOUT)
+      @logger.level = Logger.const_get(config.loglevel)
+    end
+
+    # rubocop:disable Metrics/MethodLength
+    # rubocop:disable Metrics/AbcSize
+    def create_ec2
+      @logger.info('Creating new EC2 instance.')
+      config = File.open(File.join(__dir__, '../../cfg/ec2_conf.json'),
+                         'rb', &:read).chop
+      @logger.debug("Configuration loaded: #{config}.")
+      ec2_config = symbolize(JSON.parse(config))
+      @logger.debug("Configuration symbolized: #{ec2_config}.")
+      @logger.info('Importing keys.')
+      import_keypair
+      @logger.info('Creating security group.')
+      sg_id = create_security_group
+      ec2_config[:security_group_ids] = [sg_id]
+      ec2_config[:user_data] = retrieve_user_data
+      @logger.info('Creating instance.')
+      instance = @ec2_resource.create_instances(ec2_config)[0]
+      @logger.info('Instance created. Waiting for it to become available.')
+      @ec2_resource.client.wait_until(:instance_status_ok,
+                                      instance_ids: [instance.id]) do |w|
+        w.before_wait do |_, _|
+          @logger << '.'
+        end
+      end
+      @logger.info("\n")
+      @logger.info('Instance in running state.')
+      pub_ip = @ec2_resource.instances(instance_ids: [instance.id]).first
+      @logger.info('Instance started with ip | id: ' \
+                    "#{pub_ip.public_ip_address} | #{instance.id}.")
+      [pub_ip.public_ip_address, instance.id]
+    end
+
+    def terminate_ec2(id)
+      @ec2_client.terminate_instances(dry_run: false, instance_ids: [id])
+      @ec2_resource.client.wait_until(:instance_terminated,
+                                      instance_ids: [id]) do |w|
+        w.before_wait do |_, _|
+          @logger << '.'
+        end
+      end
+      @logger.info("\n")
+      @logger.info('Instance terminated. Goodbye.')
+    end
+
+    def stop_ec2(id)
+      @ec2_client.stop_instances(dry_run: false, instance_ids: [id])
+      @ec2_resource.client.wait_until(:instance_stopped,
+                                      instance_ids: [id]) do |w|
+        w.before_wait do |_, _|
+          @logger << '.'
+        end
+      end
+      @logger.info("\n")
+      @logger.info('Instance stopped. Goodbye.')
+    end
+
+    def start_ec2(id)
+      @ec2_client.start_instances(dry_run: false, instance_ids: [id])
+      @ec2_resource.client.wait_until(:instance_running,
+                                      instance_ids: [id]) do |w|
+        w.before_wait do |_, _|
+          @logger << '.'
+        end
+      end
+      pub_ip = @ec2_resource.instances(instance_ids: [id]).first
+      @logger.info("Instance started. New ip is:#{pub_ip.public_ip_address}.")
+      pub_ip.public_ip_address
+    end
+
+    def state(id)
+      instance = @ec2_resource.instances(instance_ids: [id]).first
+      @logger.debug("Response from describe_instances: #{instance}.")
+      instance.state.name
+    end
+
+    private
+
+    def symbolize(obj)
+      case obj
+      when Hash
+        return obj.inject({}) do |memo, (k, v)|
+          memo.tap { |m| m[k.to_sym] = symbolize(v) }
+        end
+      when Array
+        return obj.map { |memo| symbolize(memo) }
+      else
+        obj
+      end
+    end
+
+    def import_keypair
+      key = Base64.decode64(File.open(File.join(__dir__, '../../cfg/minecraft.key'),
+                                      'rb', &:read).chop)
+      begin
+        @ec2_client.describe_key_pairs(key_names: ['minecraft_keys'])
+        key_exists = true
+      rescue Aws::EC2::Errors::InvalidKeyPairNotFound
+        key_exists = false
+      end
+      return if key_exists
+      resp = @ec2_client.import_key_pair(dry_run: false,
+                                         key_name: 'minecraft_keys',
+                                         public_key_material: key)
+      @logger.debug("Response from import_key_pair: #{resp}.")
+    end
+
+    def create_security_group
+      config = File.open(File.join(__dir__, '../../cfg/sg_config.json'),
+                         'rb', &:read).chop
+      sg_config = symbolize(JSON.parse(config))
+      begin
+        sg = @ec2_resource.create_security_group(dry_run: false,
+                                                 group_name: 'mine_group',
+                                                 description: 'minecraft_group')
+        sg.authorize_ingress(sg_config)
+        sg.id
+      rescue Aws::EC2::Errors::InvalidGroupDuplicate
+        @logger.info('Security Group already exists. Returning id.')
+        @ec2_resource.security_groups(group_names: ['mine_group']).first.id
+      end
+    end
+
+    def retrieve_user_data
+      user_data = File.open(File.join(__dir__, '../../cfg/user_data.sh'),
+                            'rb', &:read).chop
+      Base64.encode64(user_data)
+    end
+  end
+end

data/lib/aws_minecraft/db_helper.rb

@@ -0,0 +1,48 @@
+require 'sqlite3'
+module AWSMine
+  # Initializes the database. The format to use if there are more tables
+  # is simple. Just create a SQL file corresponding to the table name
+  # and add that table to the @tables instance variable.
+  class DBHelper
+    def initialize
+      @db = SQLite3::Database.new 'minecraft.db'
+      @tables = %w(instances)
+    end
+
+    def table_exists?(table)
+      retrieved = @db.execute <<-SQL
+        SELECT name FROM sqlite_master WHERE type='table' AND name='#{table}';
+      SQL
+      return false if retrieved.nil? || retrieved.empty?
+      retrieved.first.first == table
+    end
+
+    def init_db
+      @tables.each do |table|
+        sql = File.open(File.join(__dir__, "../../cfg/#{table}.sql"),
+                        'rb', &:read).chop
+        @db.execute sql unless table_exists? table
+      end
+    end
+
+    def instance_details
+      @db.execute('SELECT ip, id FROM instances;').first
+    end
+
+    def instance_exists?
+      !@db.execute('SELECT id FROM instances;').empty?
+    end
+
+    def store_instance(ip, id)
+      @db.execute "INSERT INTO instances VALUES ('#{ip}', '#{id}');"
+    end
+
+    def update_instance(ip, id)
+      @db.execute "UPDATE instances SET ip='#{ip}' WHERE id='#{id}';"
+    end
+
+    def remove_instance
+      @db.execute 'DELETE FROM instances;'
+    end
+  end
+end

data/lib/aws_minecraft/mine_config.rb

@@ -0,0 +1,15 @@
+require 'yaml'
+
+module AWSMine
+  # MineConfig is a configuration loader
+  class MineConfig
+    attr_reader :loglevel, :profile, :upload_path
+    def initialize
+      config = YAML.load_file(File.join(__dir__, '../../cfg/config.yml'))
+      @loglevel = config['loglevel']
+      @profile = ENV.fetch('AWS_DEFAULT_PROFILE', 'default')
+      # Upload path is used so files can sit anywhere.
+      @upload_path = config['upload_path']
+    end
+  end
+end

data/lib/aws_minecraft/ssh_helper.rb

@@ -0,0 +1,52 @@
+require 'logger'
+require_relative 'mine_config'
+
+module AWSMine
+  # Main wrapper for SSH commands
+  class SSHHelper
+    def initialize
+      config = MineConfig.new
+      @logger = Logger.new(STDOUT)
+      @logger.level = Logger.const_get(config.loglevel)
+    end
+
+    def attach_to_server(ip)
+      exec("ssh ec2-user@#{ip} -t 'cd /home/ec2-user && ./tmux-2.2/tmux attach -t #{AWSMine::MINECRAFT_SESSION_NAME}'")
+    end
+
+    def ssh(ip)
+      exec("ssh ec2-user@#{ip}")
+    end
+
+    def remote_exec(host, cmd)
+      @logger.debug("Executing '#{cmd}' on '#{host}'.")
+      # This should work if ssh key is loaded and AgentFrowarding is set to yes.
+      Net::SSH.start(host, 'ec2-user', config: true) do |ssh|
+        output = ssh.exec!(cmd)
+        @logger.info output
+      end
+    end
+
+    def stop_server(host)
+      Net::SSH.start(host, 'ec2-user', config: true) do |ssh|
+        @logger.info('Opening channel to host.')
+        channel = ssh.open_channel do |ch|
+          @logger.info('Channel opened. Opening pty.')
+          ch.request_pty do |c, success|
+            unless success
+              @logger.info('Failed to request channel.')
+              raise
+            end
+            c.on_data do |_, data|
+              puts "Received data: #{data}."
+            end
+            c.exec("cd /home/ec2-user && ./tmux-2.2/tmux attach -t #{AWSMine::MINECRAFT_SESSION_NAME}")
+            @logger.info('Sending stop signal...')
+            c.send_data("stop\n")
+          end
+        end
+        channel.wait
+      end
+    end
+  end
+end