gaptool-server 0.7.0 → 0.7.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9bdd9381a7a9adcc78aed7919ba4cdc36c718f93
-  data.tar.gz: 9d716274f9ab9c02a9c0c62e27d011d6b381029c
+  metadata.gz: 91476ed75e704cd7168262de3aee3563632c6571
+  data.tar.gz: 6e20d2d9cfd1f1e6d386bf3f8b801ef353cae179
 SHA512:
-  metadata.gz: 07863c41b56f69c29b9915deb3db26aa03a89965c48a63cf71196a0545646d2ea994e61d03b789011382bdb23da37d157e055e9ac20358a052be250f9aa37531
-  data.tar.gz: 2e3f46dc0f16ff83aab782e97a50b938c83f7b736c7a7fa38e30bb9d74755bbd6662a9b101a17766a28af9b25d5064214d1dd6b67aa516becdffcfdc3a2c6380
+  metadata.gz: db20d97b206b75e2753165da1eb30047ff8afede719f0e262477773187d19b916ec1fd9d3faae18a3e6fab08524d62fc9233c4affd0e90e9ef77634da105fbf8
+  data.tar.gz: c56b3aa929695a7b9948580ad0c65e0fdaf76c2df6d0d35d4c2c122eb0f77ca21898b46ba0a867c7014c20b7c532b73b6a44eb11e063719e2d8b201066247d9d

data/VERSION

@@ -1 +1 @@
-0.7.0
+0.7.1

data/lib/app.rb

@@ -10,6 +10,7 @@ require 'net/ssh'
 require 'peach'
 require 'airbrake'
 require 'logger'
+require 'versionomy'
 require_relative 'exceptions'
 
 class GaptoolServer < Sinatra::Application
@@ -36,6 +37,24 @@ class GaptoolServer < Sinatra::Application
     halt(401, error_response("Unauthenticated"))
   end
 
+  def check_version(server, client)
+    @@client_versions ||= {}
+    cl_v = @@client_versions[client]
+    if cl_v.nil?
+      begin
+        @@client_versions[client] = Versionomy.parse(client)
+        cl_v = @@client_versions[client]
+      rescue
+        return false
+      end
+    end
+    cl_v.major == server.major && cl_v.minor == server.minor
+  end
+
+  def invalid_version(server, client)
+    halt(400, error_response("Invalid version #{client} (server: #{server})"))
+  end
+
   error do
     status 500
     error_response
@@ -51,6 +70,11 @@ class GaptoolServer < Sinatra::Application
     disable :sessions
     enable  :dump_errors
     disable :show_exceptions
+    version = File.read(File.realpath(
+      File.join(File.dirname(__FILE__), "..", 'VERSION')
+    )).strip
+    set(:version, version)
+    set(:version_parsed, Versionomy.parse(version))
   end
 
   before do
@@ -58,6 +82,9 @@ class GaptoolServer < Sinatra::Application
       user = Gaptool::Data.user(env['HTTP_X_GAPTOOL_USER'])
       return unauthenticated if user.nil?
       return unauthenticated unless user[:key] == env['HTTP_X_GAPTOOL_KEY']
+      if !ENV['GAPTOOL_CHECK_CLIENT_VERSION'].nil? && !check_version(settings.version_parsed, env['HTTP_X_GAPTOOL_VERSION'])
+        return invalid_version(settings.version, env['HTTP_X_GAPTOOL_VERSION'])
+      end
     end
   end
 

data/lib/routes.rb

@@ -227,9 +227,7 @@ class GaptoolServer < Sinatra::Application
   end
 
   get '/version' do
-    version = File.read(File.realpath(
-      File.join(File.dirname(__FILE__), "..", 'VERSION')
-    )).strip
+    version = settings.version
     json server_version: version, api: {v0: "/"}
   end
 

data/tasks/docker.rb

@@ -23,7 +23,7 @@ unless File.exists?('/.dockerenv')
 
     desc "Run tests w/ docker"
     task :test => :build do
-      sys(%w(docker-compose run --rm gaptool rake test))
+      sys(%w(docker-compose run --rm gaptool bundle exec rake test))
     end
 
     desc "Stop docker containers"

data/test/api_test.rb

@@ -5,15 +5,21 @@ require 'set'
 describe "Test API" do
   before(:all) do
     ENV['DRYRUN'] = 'true'
+    ENV['GAPTOOL_CHECK_CLIENT_VERSION'] = 'true'
+    @version = File.read(File.realpath(
+      File.join(File.dirname(__FILE__), "..", 'VERSION')
+    )).strip.split(".")[0..1].join(".")
   end
 
   after(:all) do
     ENV['DRYRUN'] = nil
+    ENV['GAPTOOL_CHECK_CLIENT_VERSION'] = nil
   end
 
   before(:each) do
-    header 'X_GAPTOOL_USER', 'test'
-    header 'X_GAPTOOL_KEY',  'test'
+    header 'X-GAPTOOL-USER', 'test'
+    header 'X-GAPTOOL-KEY',  'test'
+    header 'X-GAPTOOL-VERSION', @version
     $redis.flushall
     DH.useradd('test', 'test')
     $time = Time.now
@@ -410,4 +416,20 @@ describe "Test API" do
     expect(last_response.status).to eq(200)
     expect(JSON.parse(last_response.body)).to eq(apps_list)
   end
+
+  it "should fail as client did not send version" do
+    header 'X-GAPTOOL-VERSION', nil
+    get "/version"
+    expect(last_response.status).to eq(400)
+    resp = JSON.parse(last_response.body)
+    expect(resp['result']).to eq('error')
+    expect(resp['message']).to match(/^Invalid version/)
+  end
+
+  it "should not check version for clients" do
+    ENV['GAPTOOL_CHECK_CLIENT_VERSION'] = nil
+    header 'X_GAPTOOL_VERSION', nil
+    get "/version"
+    expect(last_response.status).to eq(200)
+  end
 end

data/test/test_helper.rb

@@ -1,6 +1,15 @@
 ENV['RACK_ENV'] = 'test'
 if ENV['COVERAGE']
   require 'simplecov'
+  require 'simplecov-rcov'
+
+  class SimpleCov::Formatter::MergedFormatter
+    def format(result)
+       SimpleCov::Formatter::HTMLFormatter.new.format(result)
+       SimpleCov::Formatter::RcovFormatter.new.format(result)
+    end
+  end
+  SimpleCov.formatter = SimpleCov::Formatter::MergedFormatter
   SimpleCov.start do
     add_filter '/test/'
     add_group 'helpers', 'lib/helpers'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: gaptool-server
 version: !ruby/object:Gem::Version
-  version: 0.7.0
+  version: 0.7.1
 platform: ruby
 authors:
 - Matt Bailey
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-05-31 00:00:00.000000000 Z
+date: 2015-06-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sinatra
@@ -45,6 +45,9 @@ dependencies:
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.11'
+    - - ">="
       - !ruby/object:Gem::Version
         version: 2.11.1
   type: :runtime
@@ -52,6 +55,9 @@ dependencies:
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.11'
+    - - ">="
       - !ruby/object:Gem::Version
         version: 2.11.1
 - !ruby/object:Gem::Dependency
@@ -116,14 +122,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '4.1'
+        version: '4.2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '4.1'
+        version: '4.2'
 - !ruby/object:Gem::Dependency
   name: racksh
   requirement: !ruby/object:Gem::Requirement
@@ -194,6 +200,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '10'
+- !ruby/object:Gem::Dependency
+  name: versionomy
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.4'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -242,20 +262,33 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.9'
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: simplecov-rcov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.9'
+        version: '0'
 description: gaptool-server for managing cloud resources
 email: ops@gild.com
 executables:
 - gaptool-server
 - gaptool-shell
-- gaptool_server_migrate_0.6-0.7
 extensions: []
 extra_rdoc_files:
 - LICENSE.txt
@@ -269,17 +302,10 @@ files:
 - VERSION
 - bin/gaptool-server
 - bin/gaptool-shell
-- bin/gaptool_server_migrate_0.6-0.7
 - config.ru
 - lib/app.rb
 - lib/exceptions.rb
-- lib/helpers/data.rb
-- lib/helpers/ec2.rb
-- lib/helpers/init.rb
-- lib/helpers/redis.rb
-- lib/helpers/rehash.rb
 - lib/routes.rb
-- lib/views/init.erb
 - tasks/app.rb
 - tasks/config.rb
 - tasks/docker.rb

data/bin/gaptool_server_migrate_0.6-0.7

@@ -1,35 +0,0 @@
-#!/usr/bin/env ruby
-#
-# Convert all apps for new data format
-
-libpath = File.expand_path(File.join(File.dirname(__FILE__), "..", "lib"))
-$:.unshift(libpath)
-require "#{libpath}/helpers/redis"
-require "#{libpath}/helpers/data"
-DH = Gaptool::Data
-
-# -        $redis.sadd("role:#{role}:apps", name)
-# -        $redis.set("app:#{name}", role)
-# +        $redis.sadd("apps:#{environment}", name)
-# +        $redis.sadd("role:#{role}:#{environment}:apps", name)
-# +        $redis.hset("app:#{name}", environment, role)
-# -        role = $redis.get(key)
-# +        roles = $redis.hgetall(key)
-# -      role = $redis.get("app:#{app}")
-# +      return $redis.hgetall("app:#{app}")
-# -      $redis.smembers("role:#{role}:apps")
-# +      $redis.smembers("apps:#{environment}")
-# +      $redis.smembers("role:#{role}:#{environment}:apps")
-
-puts 'Removing role:*:apps'
-$redis.keys("role:*:apps").each {|k| $redis.del(k)}
-puts "Migrating apps"
-$redis.keys("app:*").each do |key|
-  app = key.sub(/app:/, "")
-  puts " * app: #{app} (#{key})"
-  role = $redis.get(key)
-  $redis.del("app:#{app}")
-  %w(staging production).each do |env|
-      DH.add_app(app, role, env)
-  end
-end

data/lib/helpers/data.rb

@@ -1,306 +0,0 @@
-require 'json'
-require 'securerandom'
-
-module Gaptool
-  module Data
-
-    def self.init_recipe
-      'recipe[init]'
-    end
-
-    def self.default_runlist
-      [init_recipe]
-    end
-
-    def self.addserver(instance, data, secret)
-      role = data['role']
-      environment = data['environment']
-      if role.nil? || environment.nil?
-        raise ArgumentError, "Missing role or environment"
-      end
-
-      if instance.nil? || instance.empty?
-        raise ArgumentError, "Missing instance"
-      end
-
-      $redis.sadd("instances", instance)
-      $redis.sadd("role:#{role}:instances", instance)
-      $redis.sadd("environment:#{environment}:instances", instance)
-      unless secret.nil?
-        data['registered'] = false
-        $redis.sadd('instances:unregistered', instance)
-        $redis.set("instances:secrets:#{data['role']}:#{data['environment']}:#{secret}", instance)
-        data['secret'] = secret
-      end
-      save_server_data instance, data
-    end
-
-    def self.overwrite_hash(key, data)
-      if !key.nil? && !data.nil? && !data.empty?
-        $redis.multi do
-          $redis.del(key)
-          $redis.hmset(key, *data.select{ |k,v| !v.nil? && ((v.is_a?(String) && !v.empty?) || (v.is_a?(Integer)) || !!v == v)}.flatten)
-        end
-      end
-    end
-
-    def self.set_server_data_attr(instance, attr, value)
-      return if value.nil? || (value.is_a?(String) && value.empty?) || !!value == value
-      $redis.hset("instance:#{instance}", attr, value)
-    end
-
-    def self.set_server_data_attributes(instance, attrs)
-      return if attrs.values.any? {|v| v.nil? || (v.is_a?(String) && v.empty?) || !!v == v}
-      $redis.hmset("instance:#{instance}", *attrs.flatten)
-    end
-
-    def self.save_server_data(instance, data)
-
-      unless data['chef_runlist'].nil?
-        data['chef_runlist'] = [*data['chef_runlist']]
-        unless data['chef_runlist'].include? init_recipe
-          data['chef_runlist'].unshift(init_recipe)
-        end
-
-        if data['chef_runlist'] == default_runlist
-          data.delete('chef_runlist')
-        else
-          data['chef_runlist'] = data['chef_runlist'].to_json
-        end
-      end
-      overwrite_hash("instance:#{instance}", data)
-    end
-
-    def self.register_server(role, environment, secret)
-      key = "instances:secrets:#{role}:#{environment}:#{secret}"
-      instance = nil
-      $redis.watch(key) do
-        instance = $redis.get(key)
-        if !instance.nil? && !instance.empty?
-          $redis.multi do |m|
-            m.hdel("instance:#{instance}", "secret")
-            m.hdel("instance:#{instance}", "registered")
-            m.srem('instances:unregistered', instance)
-            m.del(key)
-          end
-        else
-          $redis.unwatch
-          instance = nil
-        end
-      end
-      instance
-    end
-
-    def self.rmserver(instance)
-      data = get_server_data instance
-      return if data.nil?
-      $redis.multi do |m|
-        m.srem("instances", instance)
-        m.srem("role:#{data['role']}:instances", instance)
-        m.srem("environment:#{data['environment']}:instances", instance)
-        m.del("instance:#{instance}")
-      end
-      instance
-    end
-
-    def self.get_config(key)
-      $redis.hget('config', key)
-    end
-
-    def self.ensure_config(key, default)
-      cur = get_config(key)
-      cur = set_config(key, default) if cur.nil? || cur.empty?
-      cur
-    end
-
-    def self.set_config(key, value)
-      $redis.hset('config', key, value)
-      value
-    end
-
-    def self.del_config(key)
-      $redis.hdel('config', key)
-    end
-
-    def self.get_all_configs
-      $redis.hgetall('config')
-    end
-
-    def self.get_server_data(instance, opts={})
-      rs = $redis.hgetall("instance:#{instance}")
-      return nil if rs.nil? || rs.empty?
-      rs['instance'] = instance
-      if !rs['chef_runlist'].nil? && !rs['chef_runlist'].empty?
-        rs['chef_runlist'] = JSON.parse rs['chef_runlist']
-      else
-        rs['chef_runlist'] = get_runlist_for_role rs['role']
-      end
-
-      %w(chef_repo chef_branch).each do |v|
-        if rs[v].nil? || rs[v].empty?
-          rs[v] = get_config(v)
-        end
-      end
-
-      if opts[:initkey]
-        rs['initkey'] = get_config('initkey')
-      end
-
-      if !rs['terminable'].nil? && rs['terminable'] == "false"
-        rs['terminable'] = false
-      else
-        rs.delete('terminable')
-      end
-
-      if !rs['hidden'].nil? && rs['hidden'] == "true"
-        rs['hidden'] = true
-      end
-
-      if opts[:force_runlist] && rs['chef_runlist'].nil?
-        rs['chef_runlist'] = default_runlist
-      end
-
-      rs.delete_if {|k,v| v.nil? || (!!v != v && v.empty?)}
-      rs['launch_time'] = rs['launch_time'].to_i if rs['launch_time']
-      rs['apps'] = apps_in_role(rs['role'], rs['environment'])
-      rs
-    end
-
-    def self.save_role_data(role, data)
-      return if role.nil? || data.nil?
-      if data['amis']
-        amis = data.delete("amis") || {}
-        overwrite_hash("role:#{role}:amis", amis)
-      end
-      if data['sg']
-        sgs = data.delete("sg") || {}
-        overwrite_hash("role:#{role}:sg", sgs)
-      end
-      if data['apps']
-        apps = data.delete("apps")
-        apps.each {|env, app| add_app(app, role, env)}
-      end
-      overwrite_hash("role:#{role}", data)
-      $redis.sadd("roles", role)
-    end
-
-    def self.get_role_data(role, environment=nil)
-      res = $redis.hgetall("role:#{role}")
-      res['apps'] = environment ? apps_in_role(role, environment) : []
-      res['amis'] = $redis.hgetall("role:#{role}:amis")
-      res['sg'] = $redis.hgetall("role:#{role}:sg")
-      res
-    end
-
-    def self.get_ami_for_role(role, region=nil)
-      $redis.hget("role:#{role}:amis", region) || $redis.hget("amis", region)
-    end
-
-    def self.get_sg_for_role(role, environment)
-      $redis.hget("role:#{role}:sg", environment) || "#{role}-#{environment}"
-    end
-
-    def self.get_runlist_for_role(role)
-      rl = $redis.hget("role:#{role}", "chef_runlist")
-      return nil if rl.nil?
-      rl = JSON.parse rl
-      return nil if rl == default_runlist
-      rl
-    end
-
-    def self.set_amis(amis)
-      overwrite_hash("amis", amis)
-    end
-
-    def self.zones
-      $redis.hgetall('amis').keys
-    end
-
-    def self.servers_in_role(role)
-      $redis.smembers("role:#{role}:instances")
-    end
-
-    def self.servers_in_env(env)
-      $redis.smembers("environment:#{env}:instances")
-    end
-
-    def self.servers_in_role_env(role, env)
-      $redis.sinter("role:#{role}:instances", "environment:#{env}:instances")
-    end
-
-    def self.servers
-      $redis.smembers("instances")
-    end
-
-    def self.roles
-      Hash[$redis.smembers("roles").map {|r| [r, get_role_data(r)] }]
-    end
-
-    def self.add_app(name, role, environment)
-      return if name.nil? || role.nil?
-      $redis.multi do
-        $redis.sadd("apps", name)
-        $redis.sadd("apps:#{environment}", name)
-        $redis.sadd("role:#{role}:#{environment}:apps", name)
-        $redis.hset("app:#{name}", environment, role)
-      end
-    end
-
-    def self.remove_app(name)
-      return if name.nil?
-      key = "app:#{name}"
-      $redis.watch(key) do
-        roles = $redis.hgetall(key)
-        if !roles.nil?
-          $redis.multi do |m|
-            m.del(key)
-            m.srem("apps", name)
-            roles.each do |env, role|
-              m.srem("role:#{role}:#{env}:apps", name)
-            end
-          end
-        else
-          $redis.unwatch
-        end
-      end
-    end
-
-    def self.get_app_data(app)
-      return $redis.hgetall("app:#{app}")
-    end
-
-    def self.apps
-      $redis.smembers("apps")
-    end
-
-    def self.apps_in_role(role, environment)
-      $redis.smembers("role:#{role}:#{environment}:apps")
-    end
-
-    def self.stringify_apps(rs)
-      if !rs.nil? && !rs['apps'].nil?
-        rs['apps'] = rs['apps'].to_json
-      end
-      rs
-    end
-
-    def self.useradd(user, key=nil)
-      key = SecureRandom.hex(64) unless key
-      $redis.hset('users', user, key)
-      {username: user, key: key}
-    end
-
-    def self.userdel(user)
-      $redis.hdel('users', user)
-    end
-
-    def self.users
-      $redis.hgetall('users')
-    end
-
-    def self.user(user)
-      userdesc = {username: user, key: $redis.hget('users', user)}
-      return userdesc[:key].nil? ? nil : userdesc
-    end
-  end
-end

data/lib/helpers/ec2.rb

@@ -1,179 +0,0 @@
-require 'aws-sdk'
-require 'securerandom'
-require 'logger'
-require 'airbrake'
-
-# encoding: utf-8
-module Gaptool
-  module EC2
-    @@logger = Logger.new(STDERR)
-
-    def self.configure_ec2 zone
-      return if ENV['DRYRUN']
-      id = ENV['AWS_ACCESS_KEY_ID']
-      secret = ENV['AWS_SECRET_ACCESS_KEY']
-      AWS.config(access_key_id: id, secret_access_key: secret,
-                 ec2_endpoint: "ec2.#{zone}.amazonaws.com")
-    end
-
-    def self.putkey(host)
-      return "FAKEKEY", "FAKEPUB" if ENV['DRYRUN']
-      key = OpenSSL::PKey::RSA.new 2048
-      pubkey = "#{key.ssh_type} #{[key.to_blob].pack('m0')} GAPTOOL_GENERATED_KEY"
-      ENV['SSH_AUTH_SOCK'] = ''
-      Net::SSH.start(host, 'admin',
-                     :key_data => [$redis.hget('config', 'gaptoolkey')],
-                     :config => false, :keys_only => true,
-                     :paranoid => false) do |ssh|
-        ssh.exec! "grep -v GAPTOOL_GENERATED_KEY ~/.ssh/authorized_keys > /tmp/pubkeys"
-        ssh.exec! "echo #{pubkey} >> /tmp/pubkeys"
-        ssh.exec! "mv /tmp/pubkeys ~/.ssh/authorized_keys"
-      end
-      return key.to_pem, pubkey
-    end
-
-    def self.get_or_create_securitygroup(role, environment, zone, groupname=nil)
-      return "sg-test#{SecureRandom.hex(2)}" if ENV['DRYRUN']
-      configure_ec2 zone.chop
-      ec2 = AWS::EC2.new
-      groupname = groupname || "#{role}-#{environment}"
-      ec2.security_groups.each do |group|
-        if group.name == groupname
-          return group.id
-        end
-      end
-      internet = ['0.0.0.0/0']
-      sg = ec2.security_groups.create(groupname)
-      sg.authorize_ingress :tcp, 22, *internet
-      return sg.id
-    end
-
-    def self.create_ec2_instance(ec2opts, data, retries=3, sleeptime=0.5)
-      if ENV['DRYRUN']
-        id = "i-test#{SecureRandom.hex(2)}"
-        return {id: id,
-                hostname: "test-#{id}.#{data[:zone].chop}.compute.amazonaws.com",
-                instance: nil,
-                launch_time: Time.now.to_i}
-      end
-      configure_ec2 data[:zone].chop
-      ec2 = AWS::EC2.new
-
-      i = 0
-      begin
-        instance = ec2.instances.create(ec2opts)
-        @@logger.debug("Spawned instance #{instance.id}")
-      rescue => e
-        i += 1
-        raise if i > retries
-        @@logger.error("Error while creating instance: #{e}: sleeping #{sleeptime}s and retrying (#{i}/#{retries})")
-        sleep sleeptime
-        retry
-      end
-
-      i = 0
-      begin
-        hostname = instance.public_dns_name
-      rescue => e
-        i += 1
-        if i > retries
-          @@logger.error("Could not get hostname for instance #{instance} after #{retries} retries, setting to nil")
-          hostname = nil
-          Airbrake.notify_or_ignore(
-            e,
-            error_class: "EC2 public dns fail",
-            parameters: {instance: instance.id, role: data['role'], environment: data['environment'], hostname: nil}
-          )
-        else
-          @@logger.error("Error getting hostname for instance: #{e}: sleeping #{sleeptime}s and retrying (#{i}/#{retries})")
-          sleep sleeptime
-          retry
-        end
-      end
-
-      i = 0
-      begin
-        launch_time = instance.launch_time.to_i
-        raise unless launch_time.is_a? Integer
-
-      rescue => e
-        i += 1
-        if i > retries
-          @@logger.error("Cloud not get launch time for instance #{instance} after #{retries} retries. Setting to now()")
-          launch_time = Time.now.to_i
-          Airbrake.notify_or_ignore(
-            e,
-            error_class: "EC2 get launch_time fail",
-            parameters: {instance: instance.id, role: data['role'], environment: data['environment'], hostname: nil}
-          )
-        else
-          @@logger.error("Error getting launch_time for instance: #{e}: sleeping #{sleeptime}s and retrying (#{i}/#{retries})")
-          sleep sleeptime
-          retry
-        end
-      end
-
-      @@logger.info {"Instance #{instance.id} launch_time: #{launch_time} #{instance.launch_time}"}
-
-      {
-        id: instance.id,
-        instance: instance,
-        hostname: hostname,
-        launch_time: launch_time
-      }
-    end
-
-    def self.tag_ec2_instance(instance, key, value, retries=5, sleeptime=0.5)
-      return true if ENV['DRYRUN']
-      i = 0
-      begin
-        instance.add_tag(key, value: value)
-        @@logger.debug("Added tag #{key}=#{value} to #{instance.id}")
-        true
-      rescue => e
-        i += 1
-        raise if i > retries
-        @@logger.error("Error adding tag #{key} to #{instance.id}: #{e}: sleeping #{sleeptime}s and retrying (#{i}/#{retries})")
-        sleep sleeptime
-        retry
-      end
-    end
-
-    def self.terminate_ec2_instance(zone, id)
-      return if ENV['DRYRUN']
-      configure_ec2 zone
-      ec2 = AWS::EC2.new
-      instance = ec2.instances[id]
-      instance.terminate
-    end
-
-    def self.get_ec2_instance_data(zone, id)
-      if ENV['DRYRUN']
-        return {
-          hostname: 'fake.hostname.gild.com'
-        }
-      end
-      configure_ec2 zone
-      ec2 = AWS::EC2.new
-      instance = ec2.instances[id]
-      return {
-        hostname: instance.dns_name
-      }
-    end
-
-    def self.retag()
-      logger = Logger.new(STDOUT)
-      Gaptool::Data::servers.each do |id|
-        data = Gaptool::Data.get_server_data(id)
-        next if data.nil? || data['zone'].nil? || data['zone'].empty?
-        Gaptool::EC2::configure_ec2 data['zone'].chop
-        ec2 = AWS::EC2.new(region: data['zone'].chop)
-        instance = ec2.instances[id]
-        next if instance.tags.role && instance.tags.environment
-        logger.info("Retagging instance #{id} in zone #{data['zone'].chop}")
-        instance.tags.role = data['role']
-        instance.tags.environment = data['environment']
-      end
-    end
-  end
-end

data/lib/helpers/init.rb

@@ -1,4 +0,0 @@
-# encoding: utf-8
-require_relative 'ec2'
-require_relative 'rehash'
-require_relative 'data'

data/lib/helpers/redis.rb

@@ -1,23 +0,0 @@
-require 'redis'
-require 'redis-namespace'
-
-# docker links support
-unless ENV['REDIS_PORT_6379_TCP_ADDR'].nil?
-  ENV['REDIS_HOST'] = ENV['REDIS_PORT_6379_TCP_ADDR']
-  ENV['REDIS_PORT'] = ENV['REDIS_PORT_6379_TCP_PORT']
-  ENV.delete('REDIS_PASS')
-end
-
-ENV['REDIS_HOST'] = 'localhost' unless ENV['REDIS_HOST']
-ENV['REDIS_PORT'] = '6379' unless ENV['REDIS_PORT']
-ENV['REDIS_PASS'] = nil unless ENV['REDIS_PASS']
-ENV['REDIS_DB'] = '0' unless ENV['REDIS_DB']
-
-prefix = ENV.fetch('REDIS_PREFIX', 'gt')
-
-conn = Redis.new(:host => ENV['REDIS_HOST'],
-                 :port => ENV['REDIS_PORT'].to_i,
-                 :password => ENV['REDIS_PASS'],
-                 :db => ENV['REDIS_DB'].to_i)
-
-$redis = Redis::Namespace.new(prefix, redis: conn)

data/lib/helpers/rehash.rb

@@ -1,83 +0,0 @@
-require_relative "ec2"
-require_relative "data"
-require "logger"
-
-module Gaptool
-  module EC2
-    def self.rehash()
-      Gaptool::Data::servers.each do |inst|
-        Gaptool::Data::rmserver inst
-      end
-      roles = Gaptool::Data::roles
-      Gaptool::Data::zones.each do |zone|
-        Gaptool::EC2::configure_ec2 zone
-        @ec2 = AWS::EC2.new
-        ilist = []
-        @ec2.instances.each do |instance|
-          if instance.tags['gaptool'] == 'yes' && instance.status == :running
-            ilist << instance
-          end
-        end
-        ilist.each do |instance|
-          puts " - #{instance.tags['Name']}"
-          role, environment, iid = instance.tags['Name'].split('-', 3)
-          data = {
-            "zone"=> instance.availability_zone,
-            "role"=> role,
-            "environment"=> environment,
-            "hostname" => instance.public_dns_name,
-            "launch_time" => instance.launch_time.to_s,
-            "apps" => roles[role].to_s,
-            "instance"=> instance.instance_id,
-            "security_group" => instance.security_groups[0].name
-          }
-          Gaptool::Data::addserver(iid, data, nil)
-        end
-      end
-      return {"action" => "complete"}
-    end
-
-    def self.rehash_property(property)
-      Gaptool::Data::servers.each do |id|
-        rehash_property_for_instance(property, id)
-      end
-    end
-
-    def self.rehash_properties_for_instance(instance_id)
-      res = {}
-      %w[hostname itype security_group].each do |property|
-        res[property] = self.rehash_property_for_instance(property, instance_id, false)
-      end
-      Gaptool::Data::set_server_data_attributes(instance_id, res)
-    end
-
-    def self.rehash_property_for_instance(property, instance_id, save=true)
-      logger = Logger.new(STDOUT)
-      data = Gaptool::Data.get_server_data(instance_id)
-      return false if data.nil? || data['zone'].nil? || data['zone'].empty?
-      Gaptool::EC2::configure_ec2 data['zone'].chop
-      ec2 = AWS::EC2.new(region: data['zone'].chop)
-      logger.info("Updating #{property} for #{instance_id} in zone #{data['zone'].chop}")
-      instance = ec2.instances[instance_id]
-      return false if instance.nil?
-      case property
-      when "hostname"
-        value = instance.public_dns_name
-      when "itype"
-        value = instance.instance_type
-      when "security_group"
-        value = instance.security_groups[0].name
-      when "launch_time"
-        value = instance.launch_time.to_i
-      else
-        return false
-      end
-      logger.info("Setting #{property} to #{value} for #{instance_id}")
-      if save
-        Gaptool::Data.set_server_data_attr(instance_id, property, value)
-      else
-        value
-      end
-    end
-  end
-end

data/lib/views/init.erb

@@ -1,18 +0,0 @@
-#!/bin/bash
-set -e
-cd /root
-apt-get update
-apt-get install -ymq zsh git libssl-dev ruby1.9.1-full build-essential
-curl -LO https://www.getchef.com/chef/install.sh
-bash install.sh -v <%= chef_version %>
-
-cat << 'EOFKEY' > /root/.ssh/id_rsa
-<%= initkey %>
-EOFKEY
-chmod 600 /root/.ssh/id_rsa
-echo 'StrictHostKeyChecking no' > /root/.ssh/config
-
-git clone -b <%= chef_branch %> <%= chef_repo %> /root/ops
-echo '<%= json %>' > /root/init.json
-chef-solo -c /root/ops/cookbooks/init.rb -j /root/init.json -E <%= chef_environment %> && \
-    (rm /root/.ssh/id_rsa; userdel -r ubuntu; rm -rf /root/.ssh; rm -rf /root/ops)