Class: Judo::Base

Inherits:
Object
  • Object
show all
Defined in:
lib/judo/base.rb

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(options) ⇒ Base

Returns a new instance of Base.



29
30
31
32
33
34
35
36
 
# File 'lib/judo/base.rb', line 29

def initialize(options)
  @judo_dir      = options[:judo_dir]
  @repo          = options[:repo]
  @group         = options[:group]
  @bucket_name   = options[:bucket]
  @access_id     = options[:access_id]
  @access_secret = options[:access_secret]
end

Instance Attribute Details

#group ⇒ Object

Returns the value of attribute group.



27
28
29
 
# File 'lib/judo/base.rb', line 27

def group
  @group
end

#judo_dir ⇒ Object

Returns the value of attribute judo_dir.



27
28
29
 
# File 'lib/judo/base.rb', line 27

def judo_dir
  @judo_dir
end

#repo ⇒ Object

Returns the value of attribute repo.

Raises:



27
28
29
 
# File 'lib/judo/base.rb', line 27

def repo
  @repo
end

Class Method Details

.default_options(pwd, dir = find_judo_dir(pwd)) ⇒ Object 



63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
 
# File 'lib/judo/base.rb', line 63

def self.default_options(pwd, dir = find_judo_dir(pwd))
  config = YAML.load File.read("#{dir}/config.yml")
  repo_dir = config["repo"] || File.dirname(dir)
  group_config = Dir["#{repo_dir}/*/config.json"].detect { |d| File.dirname(d) == pwd }
  {
    :judo_dir      => dir,
    :group         => group_config ? File.basename(File.dirname(group_config)) : nil,
    :repo          => repo_dir,
    :bucket        => config["s3_bucket"],
    :access_id     => config["access_id"],
    :access_secret => config["access_secret"]
  }.delete_if { |key,value| value.nil? }
rescue Object => e
  puts e.inspect
  {}
end

.find_judo_dir(check) ⇒ Object 



80
81
82
83
84
85
86
87
88
89
90
 
# File 'lib/judo/base.rb', line 80

def self.find_judo_dir(check)
  if check == "/"
    if File.exists?("#{ENV['HOME']}/.judo")
      "#{ENV['HOME']}/.judo"
    else
      nil
    end
  else
    File.exists?(check + "/.judo") ? check + "/.judo" : find_judo_dir(File.dirname(check))
  end
end

Instance Method Details

#access_id ⇒ Object 



228
229
230
 
# File 'lib/judo/base.rb', line 228

def access_id
  @access_id || (raise JudoError, "no AWS Access ID specified")
end

#access_secret ⇒ Object 



232
233
234
 
# File 'lib/judo/base.rb', line 232

def access_secret
  @access_secret || (raise JudoError, "no AWS Secret Key specified")
end

#bucket ⇒ Object 



206
207
208
 
# File 'lib/judo/base.rb', line 206

def bucket
  @bucket ||= s3.bucket(bucket_name)
end

#bucket_name ⇒ Object 



236
237
238
 
# File 'lib/judo/base.rb', line 236

def bucket_name
  @bucket_name || (raise JudoError, "no S3 bucket name specified")
end

#check_version ⇒ Object 



267
268
269
 
# File 'lib/judo/base.rb', line 267

def check_version
  upgrade_db if get_db_version != db_version
end

#db_version ⇒ Object 



240
241
242
 
# File 'lib/judo/base.rb', line 240

def db_version
  2
end

#ec2 ⇒ Object 



182
183
184
 
# File 'lib/judo/base.rb', line 182

def ec2
  @ec2 ||= Aws::Ec2.new(access_id, access_secret, :logger => Logger.new(nil))
end

#ec2_instances ⇒ Object 



178
179
180
 
# File 'lib/judo/base.rb', line 178

def ec2_instances
  @ec2_instance ||= ec2.describe_instances
end

#ec2_snapshots ⇒ Object 



174
175
176
 
# File 'lib/judo/base.rb', line 174

def ec2_snapshots
  @ec2_snapshots ||= ec2.describe_snapshots
end

#ec2_volumes ⇒ Object 



170
171
172
 
# File 'lib/judo/base.rb', line 170

def ec2_volumes
  @ec2_volumes ||= ec2.describe_volumes
end

#fetch_servers_state ⇒ Object 



106
107
108
109
110
111
112
113
114
 
# File 'lib/judo/base.rb', line 106

def fetch_servers_state
  s = {}
  sdb.select("select * from #{Judo::Server.domain}")[:items].each do |group|
    group.each do |key,val|
      s[key] = val
    end
  end
  s
end

#fetch_snapshots_state ⇒ Object 



96
97
98
99
100
101
102
103
104
 
# File 'lib/judo/base.rb', line 96

def fetch_snapshots_state
  s = {}
  sdb.select("select * from #{Judo::Snapshot.domain}")[:items].each do |group|
    group.each do |key,val|
      s[key] = val
    end
  end
  s
end

#get_db_version ⇒ Object 



263
264
265
 
# File 'lib/judo/base.rb', line 263

def get_db_version
  @db_version ||= sdb.get_attributes("judo_config", "judo")[:attributes]["dbversion"].first.to_i
end

#get_group(name) ⇒ Object 



144
145
146
147
148
 
# File 'lib/judo/base.rb', line 144

def get_group(name)
  group = groups.detect { |g| g.name == name }
  group ||= Judo::Group.new(self, name, 0)
  group
end

#group_versions ⇒ Object 



190
191
192
 
# File 'lib/judo/base.rb', line 190

def group_versions
  @group_version ||= sdb.get_attributes("judo_config", "group_versions")[:attributes]
end

#groups ⇒ Object 



162
163
164
 
# File 'lib/judo/base.rb', line 162

def groups
  @groups ||= group_versions.map { |name,ver| Judo::Group.new(self, name, ver.first.to_i ) }
end

#groups_config ⇒ Object 



186
187
188
 
# File 'lib/judo/base.rb', line 186

def groups_config
  @groups_config ||= sdb.get_attributes("judo_config", "groups")[:attributes]
end

#instance_id_to_judo(instance_id) ⇒ Object 



198
199
200
 
# File 'lib/judo/base.rb', line 198

def instance_id_to_judo(instance_id)
  servers.detect { |s| s.instance_id and s.instance_id == instance_id }
end

#ip_to_judo(ip) ⇒ Object 



194
195
196
 
# File 'lib/judo/base.rb', line 194

def ip_to_judo(ip)
  servers.detect { |s| s.elastic_ip == ip }
end

#ips ⇒ Object 



52
53
54
55
56
57
58
59
60
61
 
# File 'lib/judo/base.rb', line 52

def ips
  @ips ||= ec2.describe_addresses.map do |ip|
    {
      :ip          => ip[:public_ip],
      :instance_id => ip[:instance_id],
      :attached_to => instance_id_to_judo(ip[:instance_id]),
      :assigned_to => ip_to_judo(ip[:public_ip])
    }
  end
end

#new_server(name, group) ⇒ Object 



132
133
134
135
136
 
# File 'lib/judo/base.rb', line 132

def new_server(name, group)
  s = Judo::Server.new(self, name, group)
  servers << s
  s
end

#new_snapshot(name, server) ⇒ Object 



138
139
140
141
142
 
# File 'lib/judo/base.rb', line 138

def new_snapshot(name, server)
  s = Judo::Snapshot.new(self, name, server)
  snapshots << s
  s
end

#reload_ec2_instances ⇒ Object 



166
167
168
 
# File 'lib/judo/base.rb', line 166

def reload_ec2_instances
  @ec2_instance = nil
end

#s3 ⇒ Object 



202
203
204
 
# File 'lib/judo/base.rb', line 202

def s3
  @s3 ||= Aws::S3.new(access_id, access_secret, :logger => Logger.new(nil))
end

#s3_get(k) ⇒ Object 



214
215
216
 
# File 'lib/judo/base.rb', line 214

def s3_get(k)
  bucket.get(k)
end

#s3_put(k, file) ⇒ Object 



218
219
220
 
# File 'lib/judo/base.rb', line 218

def s3_put(k, file)
  bucket.put(k, file)
end

#s3_url(k) ⇒ Object 



210
211
212
 
# File 'lib/judo/base.rb', line 210

def s3_url(k)
  Aws::S3Generator::Key.new(bucket, k).get
end

#sdb ⇒ Object 



92
93
94
 
# File 'lib/judo/base.rb', line 92

def sdb
  @sdb ||= Aws::SdbInterface.new(access_id, access_secret, :logger => Logger.new(nil))
end

#servers ⇒ Object 



128
129
130
 
# File 'lib/judo/base.rb', line 128

def servers
  @servers ||= servers_state.map { |name,data| Judo::Server.new(self, name, data["group"].first) }
end

#servers_state ⇒ Object 



120
121
122
 
# File 'lib/judo/base.rb', line 120

def servers_state
  @servers_state ||= fetch_servers_state
end

#set_db_version(new_version) ⇒ Object 



258
259
260
261
 
# File 'lib/judo/base.rb', line 258

def set_db_version(new_version)
  @db_version = new_version
  sdb.put_attributes("judo_config", "judo", { "dbversion" => new_version }, :replace)
end

#snapshots ⇒ Object 



124
125
126
 
# File 'lib/judo/base.rb', line 124

def snapshots
  @snapshots ||= snapshots_state.map { |name,data| Judo::Snapshot.new(self, name, data["server"].first) }
end

#snapshots_state ⇒ Object 



116
117
118
 
# File 'lib/judo/base.rb', line 116

def snapshots_state
  @snapshots_state ||= fetch_snapshots_state
end

#task(msg, &block) ⇒ Object 



150
151
152
153
154
155
156
157
158
159
160
 
# File 'lib/judo/base.rb', line 150

def task(msg, &block)
  printf "---> %-24s ", "#{msg}..."
  STDOUT.flush
  start = Time.now
  result = block.call
  result = "done" unless result.is_a? String
  finish = Time.now
  time = sprintf("%0.1f", finish - start)
  puts "#{result} (#{time}s)"
  result
end

#upgrade_db ⇒ Object 



244
245
246
247
248
249
250
251
252
253
254
255
256
 
# File 'lib/judo/base.rb', line 244

def upgrade_db
  case get_db_version
    when 0
      raise JudoError, "Your db appears to be unititialized.  You will need to do a judo init"
    when 1
      task("Upgrading Judo: Creating Snapshots SDB Domain") do
        sdb.create_domain(Judo::Snapshot.domain)
        set_db_version(2)
      end
    else
      raise JduoError, "judo db is newer than the current gem - upgrade judo and try again"
  end
end

#volumes ⇒ Object 



38
39
40
41
42
43
44
45
46
47
48
49
50
 
# File 'lib/judo/base.rb', line 38

def volumes
  @volumes ||= ec2_volumes.map do |v|
    {
      :id          => v[:aws_id],
      :size        => v[:aws_size],
      :status      => v[:aws_status],
      :device      => v[:aws_device],
      :instance_id => v[:aws_instance_id],
      :attached_to => instance_id_to_judo(v[:aws_instance_id]),
      :assigned_to => servers.detect { |s| s.volumes.invert[v[:aws_id]] }
    }
  end
end