gaptool-server 0.6.6 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6323ce0f24d59f15f894675c6cf76724f5b8ace1
-  data.tar.gz: 4af7e863c6b3527d54ff458fa29cdaebf09583eb
+  metadata.gz: 9bdd9381a7a9adcc78aed7919ba4cdc36c718f93
+  data.tar.gz: 9d716274f9ab9c02a9c0c62e27d011d6b381029c
 SHA512:
-  metadata.gz: 8bb6202e2fc26965a53acad59625830ea198cd7c930414d005b4977291a49c1a79823e5a29ad00c8c97ed68f0a979ab047f93d5933203455f199138d29f7a1b0
-  data.tar.gz: 97cdc9abf27d57332ef261dac8b7919bd732102362d6b5a79bf70b26df9870ab4e1c8911edfe8c2c59a3cf050036f1a9f77477a355988f6f82a2cc82f25fcc31
+  metadata.gz: 07863c41b56f69c29b9915deb3db26aa03a89965c48a63cf71196a0545646d2ea994e61d03b789011382bdb23da37d157e055e9ac20358a052be250f9aa37531
+  data.tar.gz: 2e3f46dc0f16ff83aab782e97a50b938c83f7b736c7a7fa38e30bb9d74755bbd6662a9b101a17766a28af9b25d5064214d1dd6b67aa516becdffcfdc3a2c6380

data/Rakefile

@@ -32,7 +32,7 @@ unless File.exists?('/.dockerenv')
 
   desc "Start the HTTP server"
   task :server do
-    exec "unicorn -p 3000 #{Shellwords.join(ARGV[1..-1])}"
+    exec "puma -p 3000 --preload -t 8:32 -w 3 #{Shellwords.join(ARGV[1..-1])}"
   end
 
   desc "Bump the version"

data/VERSION

@@ -1 +1 @@
-0.6.6
+0.7.0

data/bin/gaptool-server

@@ -8,4 +8,4 @@ rescue LoadError
   root = File.realpath(File.join(File.dirname(__FILE__), ".."))
 end
 Dir.chdir(root)
-exec "unicorn #{ARGV.join(" ")}"
+exec "puma #{ARGV.join(" ")}"

data/bin/gaptool_server_migrate_0.6-0.7

@@ -0,0 +1,35 @@
+#!/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

@@ -39,7 +39,7 @@ module Gaptool
       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 == v)}.flatten)
+          $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
@@ -152,12 +152,17 @@ module Gaptool
         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['apps'] = apps_in_role(rs['role'])
+      rs['launch_time'] = rs['launch_time'].to_i if rs['launch_time']
+      rs['apps'] = apps_in_role(rs['role'], rs['environment'])
       rs
     end
 
@@ -172,16 +177,16 @@ module Gaptool
         overwrite_hash("role:#{role}:sg", sgs)
       end
       if data['apps']
-        apps = data.delete("apps") || []
-        apps.each {|a| add_app(a, role)}
+        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)
+    def self.get_role_data(role, environment=nil)
       res = $redis.hgetall("role:#{role}")
-      res['apps'] = apps_in_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
@@ -231,12 +236,13 @@ module Gaptool
       Hash[$redis.smembers("roles").map {|r| [r, get_role_data(r)] }]
     end
 
-    def self.add_app(name, role)
+    def self.add_app(name, role, environment)
       return if name.nil? || role.nil?
       $redis.multi do
         $redis.sadd("apps", name)
-        $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)
       end
     end
 
@@ -244,12 +250,14 @@ module Gaptool
       return if name.nil?
       key = "app:#{name}"
       $redis.watch(key) do
-        role = $redis.get(key)
-        if !role.nil?
+        roles = $redis.hgetall(key)
+        if !roles.nil?
           $redis.multi do |m|
             m.del(key)
             m.srem("apps", name)
-            m.srem("role:#{role}:apps", name)
+            roles.each do |env, role|
+              m.srem("role:#{role}:#{env}:apps", name)
+            end
           end
         else
           $redis.unwatch
@@ -258,16 +266,15 @@ module Gaptool
     end
 
     def self.get_app_data(app)
-      role = $redis.get("app:#{app}")
-      return {"role" => role } unless role.nil?
+      return $redis.hgetall("app:#{app}")
     end
 
     def self.apps
       $redis.smembers("apps")
     end
 
-    def self.apps_in_role(role)
-      $redis.smembers("role:#{role}:apps")
+    def self.apps_in_role(role, environment)
+      $redis.smembers("role:#{role}:#{environment}:apps")
     end
 
     def self.stringify_apps(rs)

data/lib/helpers/ec2.rb

@@ -54,7 +54,7 @@ module Gaptool
         return {id: id,
                 hostname: "test-#{id}.#{data[:zone].chop}.compute.amazonaws.com",
                 instance: nil,
-                launch_time: Time.now.to_s}
+                launch_time: Time.now.to_i}
       end
       configure_ec2 data[:zone].chop
       ec2 = AWS::EC2.new
@@ -71,13 +71,6 @@ module Gaptool
         retry
       end
 
-      begin
-        launch_time = instance.launch_time.to_s
-        launch_time = launch_time.empty? ? Time.now.to_s : launch_time
-      rescue
-        launch_time = Time.now.to_s
-      end
-
       i = 0
       begin
         hostname = instance.public_dns_name
@@ -89,7 +82,7 @@ module Gaptool
           Airbrake.notify_or_ignore(
             e,
             error_class: "EC2 public dns fail",
-            parameters: {instance: instance[:id], role: data['role'], environment: data['environment'], hostname: nil}
+            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})")
@@ -97,6 +90,31 @@ module Gaptool
           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,
@@ -142,5 +160,20 @@ module Gaptool
         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/rehash.rb

@@ -48,7 +48,7 @@ module Gaptool
       %w[hostname itype security_group].each do |property|
         res[property] = self.rehash_property_for_instance(property, instance_id, false)
       end
-      Gaptool::set_server_data_attributes(instance_id, res)
+      Gaptool::Data::set_server_data_attributes(instance_id, res)
     end
 
     def self.rehash_property_for_instance(property, instance_id, save=true)
@@ -67,11 +67,13 @@ module Gaptool
         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
-        logger.info("Setting #{property} to #{value} for #{instance_id}")
         Gaptool::Data.set_server_data_attr(instance_id, property, value)
       else
         value

data/lib/routes.rb

@@ -67,7 +67,7 @@ class GaptoolServer < Sinatra::Application
     end
 
     # Add host tag
-    data.merge(instance.reject { |k, v| [:id, :instance].include?(k) })
+    data.merge!(Hash[instance.reject { |k, v| [:id, :instance].include?(k) }.map {|k, v| [k.to_s, v]}])
     Gaptool::Data::addserver(instance[:id], data, secret)
     json({instance: instance[:id],
           ami: image_id,
@@ -136,24 +136,37 @@ class GaptoolServer < Sinatra::Application
   end
 
   get '/hosts' do
-    servers = Gaptool::Data::servers.map do |inst|
+    filter = !!params['hidden'] ? Proc.new {|s| !s['registered']} : Proc.new { |s| !s['registered'] && !s['hidden'] == true}
+    json(Gaptool::Data::servers.map do |inst|
       Gaptool::Data::get_server_data inst
-    end.select{ |s| !s['registered']}
-    json servers
+    end.select(&filter))
   end
 
   get '/apps' do
-    out = {}
-    Gaptool::Data.apps.each do |app|
-      out["app:#{app}"] = Gaptool::Data::get_app_data(app)
+    json(Hash[Gaptool::Data.apps.map {|a| ["app:#{a}", Gaptool::Data::get_app_data(a)]}])
+  end
+
+  get '/app/:app/:environment/hosts' do
+    app_data = Gaptool::Data::get_app_data(params[:app])
+    unless app_data
+      status 404
+      error_response "app '#{params[:apps]}' not found"
     end
-    json out
+
+    role = app_data[params[:environment]]
+    list = Gaptool::Data::servers_in_role_env role, params[:environment]
+    filter = !!params['hidden'] ? Proc.new {|s| false } : Proc.new { |s| s['hidden']}
+    json(list.map do |inst|
+      data = Gaptool::Data::get_server_data(inst)
+      Gaptool::Data::stringify_apps(data)
+    end.delete_if(&filter))
   end
 
   get '/hosts/:role' do
+    filter = !!params['hidden'] ? Proc.new {|s| !s['registered']} : Proc.new { |s| !s['registered'] && !s['hidden'] == true}
     servers =  Gaptool::Data::servers_in_role(params[:role]).map do |inst|
-      Gaptool::Data::get_server_data inst
-    end.select{ |s| !s['registered'] }
+      Gaptool::Data::get_server_data(inst)
+    end.select(&filter)
     json servers
   end
 
@@ -167,15 +180,37 @@ class GaptoolServer < Sinatra::Application
     end
   end
 
+  patch '/instance/:id' do
+    rs = Gaptool::Data::get_server_data(params[:id])
+    if rs.nil?
+      status 404
+      error_response "instance with id '#{params[:id]}' not found"
+    else
+      data = JSON.parse(request.body.read)
+      if !data['hidden'].nil?
+        hidden = !!data['hidden']
+        rs["hidden"] = hidden if hidden == true
+        rs.delete("hidden") if hidden == false
+      end
+      if !data['terminable'].nil?
+        rs["terminable"] = !!data['terminable']
+      end
+      Gaptool::Data::save_server_data params[:id], rs
+      json Gaptool::Data::stringify_apps(rs)
+    end
+  end
+
   get '/hosts/:role/:environment' do
     if params[:role] == 'ALL'
       list = Gaptool::Data::servers_in_env params[:environment]
     else
       list = Gaptool::Data::servers_in_role_env params[:role], params[:environment]
     end
+    filter = !!params['hidden'] ? Proc.new {|s| false } : Proc.new { |s| s['hidden']}
     servers = list.map do |inst|
-      Gaptool::Data::stringify_apps(Gaptool::Data::get_server_data(inst))
-    end
+      data = Gaptool::Data::get_server_data(inst)
+      Gaptool::Data::stringify_apps(data)
+    end.delete_if(&filter)
 
     json servers
   end

data/tasks/app.rb

@@ -1,14 +1,20 @@
 namespace :app do
   desc "Add an application"
-  task :add, [:app, :role] do |t, args|
-    abort("Missing parameters") if args[:app].nil? || args[:app].empty? || args[:role].nil? || args[:role].empty?
+  task :add, [:app, :role, :environment] do |t, args|
+    [:app, :role, :environment].each do |arg|
+      abort("Missing parameter #{arg}") if args[arg].nil? || args[arg].empty?
+    end
     ex = DH.get_app_data(args[:app])
     unless ex.nil?
-      puts "Updating application #{args[:app]}" unless ex.nil?
+      puts "Updating application #{args[:app]} (#{args[:environment]}) to #{args[:role]}"
       DH.remove_app(args[:app])
+      ex.delete(args[:environment])
+    end
+    DH.add_app(args[:app], args[:role], args[:environment])
+    ex.each do |env, role|
+      DH.add_app(args[:app], role, env)
     end
-    DH.add_app(args[:app], args[:role])
-    puts "Added app #{args[:app]} in role #{args[:role]}"
+    puts "Added app #{args[:app]}, role #{args[:role]}, environment: #{args[:environment]}"
   end
 
   desc "Remove an application"
@@ -25,9 +31,20 @@ namespace :app do
     if info.nil? || info.empty?
       puts "No such app #{args[:app]}"
     else
-      puts " * #{args[:app]} => #{info["role"]}"
+      puts " * #{app} #{info.map {|k,v| "#{k}: #{v}"}.join(", ")}"
     end
+  end
 
+  desc "Copy all apps for a role to a new env"
+  task :newenv, [:role, :oldenv, :newenv, :newrole] do |t, args|
+    [:role, :oldenv, :newenv].each do |k|
+      abort "Missing parameter #{k}" if args[k].nil?
+    end
+    newrole = args[:newrole] || args[:role]
+    DH.apps_in_role(args[:role], args[:oldenv]).each do |app|
+      puts " * app: #{app} to role #{newrole} (#{args[:newenv]})"
+      DH.add_app(app, newrole, args[:newenv])
+    end
   end
 end
 
@@ -36,6 +53,6 @@ task :app do
   puts "Apps:"
   DH.apps.each do |app|
     info = DH.get_app_data(app)
-    puts " * #{app} => #{info["role"]}"
+    puts " * #{app} #{info.map {|k,v| "#{k}: #{v}"}.join(", ")}"
   end
 end

data/tasks/docker.rb

@@ -23,17 +23,17 @@ unless File.exists?('/.dockerenv')
 
     desc "Run tests w/ docker"
     task :test => :build do
-      sys(%w(fig run --rm gaptool rake test))
+      sys(%w(docker-compose run --rm gaptool rake test))
     end
 
     desc "Stop docker containers"
     task :stop do
-      sys(%w(fig stop))
+      sys(%w(docker-compose stop))
     end
 
     desc "Start docker containers"
     task :start do
-      sys(%w(fig start))
+      sys(%w(docker-compose start))
     end
 
     desc "Restart docker containers"
@@ -41,19 +41,19 @@ unless File.exists?('/.dockerenv')
 
     desc "Stop and remove docker containers (alias 'rm')"
     task :remove => :stop do
-      sys(%w(fig rm --force))
+      sys(%w(docker-compose rm --force))
     end
 
     task :rm => :remove
 
     desc "Recreate docker containers without building"
     task :recreate do
-      sys(%w(fig up -d))
+      sys(%w(docker-compose up -d))
     end
 
     desc "Run a command in the docker container"
     task :run do
-      exit sys(%W(fig run --rm gaptool #{ARGV[1..-1].shelljoin}))
+      exit sys(%W(docker-compose run --rm gaptool #{ARGV[1..-1].shelljoin}))
     end
   end
 

data/tasks/ec2.rb

@@ -1,4 +1,10 @@
 namespace :ec2 do
+
+  desc "Tag all (untagged) instances with role and environment"
+  task :retag do |t|
+    EC2.retag
+  end
+
   desc "Rehash instances"
   task :rehash do |t|
     EC2.rehash

data/tasks/role.rb

@@ -2,7 +2,7 @@ namespace :role do
   desc "Set security group for a role"
   task :set_sg, [:role, :environment, :security_group] do |t, args|
     abort("Missing parameters") if args[:role].nil? || args[:environment].nil? || args[:role].empty? || args[:environment].empty? || args[:security_group].nil? || args[:security_group].empty?
-    role = DH.get_role_data(args[:role])
+    role = DH.get_role_data(args[:role], args[:environment])
     role['sg'].merge!(args[:environment] => args[:security_group])
     DH.save_role_data(args[:role], role)
   end

data/test/api_test.rb

@@ -16,6 +16,7 @@ describe "Test API" do
     header 'X_GAPTOOL_KEY',  'test'
     $redis.flushall
     DH.useradd('test', 'test')
+    $time = Time.now
   end
 
   def add_and_register_server data=nil
@@ -45,7 +46,8 @@ describe "Test API" do
       'terminable' => true,
       'zone' => 'my-zone-1a',
       'itype' => 'm1.type',
-      "hostname" => 'fake.hostname.gild.com'
+      "hostname" => 'fake.hostname.gild.com',
+      "launch_time" => $time.to_i
     }
   end
 
@@ -67,7 +69,8 @@ describe "Test API" do
   it "should create a instance" do
     post '/init', host_data.to_json
     expect(last_response.status).to eq(200)
-    expect(JSON.parse(last_response.body).keys).to eq(["instance", "ami", "role", "hostname", "launch_time", "environment", "secret", "terminable", "security_group"])
+    expect(JSON.parse(last_response.body).keys).to eq(["instance", "ami", "role", "hostname", "launch_time",
+                                                       "environment", "secret", "terminable", "security_group"])
   end
 
   it "should get the runlist from the role" do
@@ -96,6 +99,86 @@ describe "Test API" do
     expect(resp['security_group']).to eq("#{host_data['role']}-#{host_data['environment']}")
   end
 
+  it "should set instance unterminable" do
+    id = add_and_register_server()['instance']
+
+    get "/instance/#{id}"
+    expect(last_response.status).to eq(200)
+    resp = JSON.parse(last_response.body)
+    expect(resp.keys).not_to include("terminable")
+
+    patch "/instance/#{id}", {terminable: false}.to_json
+    expect(last_response.status).to eq(200)
+    resp = JSON.parse(last_response.body)
+    expect(resp['terminable']).to eq(false)
+
+    get "/instance/#{id}"
+    expect(last_response.status).to eq(200)
+    resp = JSON.parse(last_response.body)
+    expect(resp['terminable']).to eq(false)
+
+    post '/terminate', {'id' => id}.to_json
+    expect(last_response.status).to eq(409)
+
+    patch "/instance/#{id}", {terminable: true}.to_json
+    expect(last_response.status).to eq(200)
+    resp = JSON.parse(last_response.body)
+    expect(resp['terminable']).to eq(true)
+
+    post '/terminate', {'id' => id}.to_json
+    expect(last_response.status).to eq(200)
+  end
+
+  it "should set an instance as hidden" do
+    id = add_and_register_server()['instance']
+
+    get "/instance/#{id}"
+    expect(last_response.status).to eq(200)
+    resp = JSON.parse(last_response.body)
+    expect(resp.keys).not_to include("hidden")
+
+    patch "/instance/#{id}", {hidden: false}.to_json
+    expect(last_response.status).to eq(200)
+    resp = JSON.parse(last_response.body)
+    expect(resp.keys).not_to include("hidden")
+
+    get "/instance/#{id}"
+    expect(last_response.status).to eq(200)
+    resp = JSON.parse(last_response.body)
+    expect(resp.keys).not_to include("hidden")
+
+    patch "/instance/#{id}", {hidden: true}.to_json
+    expect(last_response.status).to eq(200)
+    resp = JSON.parse(last_response.body)
+    expect(resp['hidden']).to eq(true)
+
+    get "/instance/#{id}"
+    expect(last_response.status).to eq(200)
+    resp = JSON.parse(last_response.body)
+    expect(resp['hidden']).to eq(true)
+
+    get "/host/#{host_data['role']}/#{host_data['environment']}/#{id}"
+    expect(last_response.status).to eq(200)
+    resp = JSON.parse(last_response.body)
+    expect(resp['hidden']).to eq(true)
+
+    get "/hosts"
+    expect(last_response.status).to eq(200)
+    expect(JSON.parse(last_response.body)).to eq([])
+
+    get "/hosts/#{host_data['role']}"
+    expect(last_response.status).to eq(200)
+    expect(JSON.parse(last_response.body)).to eq([])
+
+    get "/hosts/#{host_data['role']}/#{host_data['environment']}"
+    expect(last_response.status).to eq(200)
+    expect(JSON.parse(last_response.body)).to eq([])
+
+    get "/hosts/ALL/#{host_data['environment']}"
+    expect(last_response.status).to eq(200)
+    expect(JSON.parse(last_response.body)).to eq([])
+  end
+
   it "should remove default runlist" do
     id = add_and_register_server(host_data.merge("chef_runlist"=> ['recipe[init]']))['instance']
     get "/host/testrole/testenv/#{id}"
@@ -226,6 +309,30 @@ describe "Test API" do
     expect(JSON.parse(last_response.body).to_set).to eq(exp_data)
   end
 
+  it "should find one hidden host" do
+    id1 = add_and_register_server()['instance']
+    id2 = add_and_register_server()['instance']
+    patch "/instance/#{id1}", {hidden: true}.to_json
+    %W(/hosts /hosts/#{host_data['role']} /hosts/#{host_data['role']}/#{host_data['environment']} /hosts/ALL/#{host_data['environment']}).each do |url|
+      get url
+      expect(last_response.status).to eq(200)
+      res = JSON.parse(last_response.body).map{|x| x.delete('apps'); x}.to_set
+      exp_data = [host_data.reject{|k,v| k == 'terminable'}.merge({'instance' => id2,
+                                                                   'chef_runlist' => expanded_runlist})].to_set
+      expect(res).to eq(exp_data)
+      get url, {hidden: true}
+      expect(last_response.status).to eq(200)
+      exp_data = [
+        host_data.reject{|k,v| k == 'terminable'}.merge({'instance' => id1,
+                                                        'chef_runlist' => expanded_runlist,
+                                                        'hidden' => true}),
+        host_data.reject{|k,v| k == 'terminable'}.merge({'instance' => id2,
+                                                        'chef_runlist' => expanded_runlist})
+      ].to_set
+      expect(JSON.parse(last_response.body).map{|x| x.delete('apps'); x}.to_set).to eq(exp_data)
+    end
+  end
+
   it "should find an host by role" do
     other = host_data.merge({'role' => 'otherrole'})
     id1 = add_and_register_server(other)['instance']
@@ -295,10 +402,10 @@ describe "Test API" do
   end
 
   it "should return the list of apps" do
-    DH.add_app("firstapp", "testrole")
-    DH.add_app("secondapp", "testrole")
-    apps_list = {"app:firstapp" => {"role" => "testrole"},
-                 "app:secondapp" =>{"role" => "testrole"}}
+    DH.add_app("firstapp", "testrole", "testenv")
+    DH.add_app("secondapp", "testrole", "testenv")
+    apps_list = {"app:firstapp" => {"testenv" => "testrole"},
+                 "app:secondapp" => {"testenv" => "testrole"}}
     get "/apps"
     expect(last_response.status).to eq(200)
     expect(JSON.parse(last_response.body)).to eq(apps_list)

data/test/data_test.rb

@@ -105,7 +105,7 @@ describe "data helpers" do
   it "should get the runlist for a node from the role" do
     DH.save_role_data("role", chef_runlist: ["recipe[myrecipe]"].to_json)
     DH.addserver(instid, data, nil)
-    role = DH.get_role_data("role")
+    role = DH.get_role_data("role", "testenv")
     expect(role).to eq({"chef_runlist"=> ["recipe[myrecipe]"].to_json,
                         "apps" => [],
                         "amis" => {},
@@ -121,19 +121,19 @@ describe "data helpers" do
   it "shoud get the ami for a node from the role" do
     DH.save_role_data("role", ami: 'ami-1234567')
     DH.addserver(instid, data, nil)
-    role = DH.get_role_data("role")
+    role = DH.get_role_data("role", "testenv")
     expect(role).to eq({'ami' => 'ami-1234567',
                         "apps" => [],
                         "amis" => {},
                         "sg" => {}})
   end
 
-    it "shoud get the sg for a node from the role" do
-      DH.save_role_data("role", ami: 'ami-1234567', "sg" => {"test" => "my_role"})
-      role = DH.get_role_data("role")
-      expect(role).to eq({'ami' => 'ami-1234567',
-                          "apps" => [],
-                          "amis" => {},
-                          "sg" => {"test" => "my_role"}})
+  it "shoud get the sg for a node from the role" do
+    DH.save_role_data("role", ami: 'ami-1234567', "sg" => {"test" => "my_role"})
+    role = DH.get_role_data("role", "testenv")
+    expect(role).to eq({'ami' => 'ami-1234567',
+                        "apps" => [],
+                        "amis" => {},
+                        "sg" => {"test" => "my_role"}})
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: gaptool-server
 version: !ruby/object:Gem::Version
-  version: 0.6.6
+  version: 0.7.0
 platform: ruby
 authors:
 - Matt Bailey
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-01-22 00:00:00.000000000 Z
+date: 2015-05-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sinatra
@@ -41,19 +41,19 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '1.4'
 - !ruby/object:Gem::Dependency
-  name: unicorn
+  name: puma
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '4.8'
+        version: 2.11.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '4.8'
+        version: 2.11.1
 - !ruby/object:Gem::Dependency
   name: redis
   requirement: !ruby/object:Gem::Requirement
@@ -180,6 +180,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.8'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -241,7 +255,7 @@ email: ops@gild.com
 executables:
 - gaptool-server
 - gaptool-shell
-- gaptool_migrate_security_groups
+- gaptool_server_migrate_0.6-0.7
 extensions: []
 extra_rdoc_files:
 - LICENSE.txt
@@ -255,7 +269,7 @@ files:
 - VERSION
 - bin/gaptool-server
 - bin/gaptool-shell
-- bin/gaptool_migrate_security_groups
+- bin/gaptool_server_migrate_0.6-0.7
 - config.ru
 - lib/app.rb
 - lib/exceptions.rb
@@ -298,7 +312,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.3
+rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
 summary: gaptool-server for managing cloud resources

data/bin/gaptool_migrate_security_groups

@@ -1,18 +0,0 @@
-#!/usr/bin/env ruby
-#
-# convert the old data model for the gaptool server
-# to the new struct
-
-libpath = File.expand_path(File.join(File.dirname(__FILE__), "..", "lib"))
-$:.unshift(libpath)
-require "#{libpath}/helpers/redis"
-require "#{libpath}/helpers/data"
-DH = Gaptool::Data
-
-$redis.keys("role:*").each do |k|
-  next if k.end_with?('instances') || k.end_with?('apps') || k.end_with?('amis')
-  puts "Migrating #{k}"
-  sgroup = $redis.hget(k, "security_group")
-  $redis.hset("#{k}:sg", "production", sgroup)
-  $redis.del(k)
-end