lib/judo/server.rb in judo-0.3.1 vs lib/judo/server.rb in judo-0.3.2
- old
+ new
@@ -1,42 +1,40 @@
module Judo
class Server
- attr_accessor :name, :group_name
+ attr_accessor :id,:group_name
- def initialize(base, name, group, version = nil)
+ def initialize(base, id, group, version = nil)
@base = base
- @name = name
+ @id = id
@group_name = group
end
- def create(options)
+ def create(name, options)
raise JudoError, "no group specified" unless group_name
options[:virgin] = true if options[:virgin].nil?
snapshots = options[:snapshots]
note = options[:note] ## a user defined note field
data = options[:data] ## instance specific data passed in JUDO_DATA
ip = options[:elastic_ip] ## if the ip was allocated beforehand
virgin = options[:virgin] ## should the server init?
+ clone = options[:clone] ## if it was cloned from a snapshot
version = options[:version]
version ||= group.version
- if @name.nil?
- index = @base.servers.map { |s| (s.name =~ /^#{s.group.name}.(\d*)$/); $1.to_i }.sort.last.to_i + 1
- @name = "#{group.name}.#{index}"
- end
+ raise JudoError, "there is already a server named #{name}" if @base.servers.detect { |s| s.name == name and s != self}
+ raise JudoError, "there is already a server with id #{id}" if @base.servers.detect { |s| s.id == id and s != self}
- raise JudoError, "there is already a server named #{name}" if @base.servers.detect { |s| s.name == @name and s != self}
-
task("Creating server #{name}") do
update "name" => name, "group" => group_name,
"note" => note, "virgin" => virgin,
"secret" => new_secret, "version" => version,
- "data" => data, "elastic_ip" => ip
- @base.sdb.put_attributes(@base.base_domain, "groups", group_name => name)
+ "data" => data, "elastic_ip" => ip,
+ "clone" => clone, "created_at" => Time.now.to_i
+ @base.sdb.put_attributes(@base.base_domain, "groups", group_name => id)
end
allocate_disk(snapshots)
allocate_ip
@@ -46,21 +44,37 @@
def group
@group ||= @base.groups.detect { |g| g.name == group_name }
end
def fetch_state
- @base.sdb.get_attributes(@base.server_domain, name)[:attributes]
+ @base.sdb.get_attributes(@base.server_domain, id)[:attributes]
end
def state
- @base.servers_state[name] ||= fetch_state
+ @base.servers_state[id] ||= fetch_state
end
def get(key)
state[key] && [state[key]].flatten.first
end
+ def created_at
+ Time.at(get("created_at").to_i)
+ end
+
+ def started_at
+ Time.at(get("started_at").to_i)
+ end
+
+ def stopped_at
+ Time.at(get("stopped_at").to_i)
+ end
+
+ def name
+ get "name"
+ end
+
def data
get "data"
end
def instance_id
@@ -126,32 +140,32 @@
def volumes
Hash[ (state["volumes"] || []).map { |a| a.split(":") } ]
end
def update(attrs)
- @base.sdb.put_attributes(@base.server_domain, name, attrs, :replace)
+ @base.sdb.put_attributes(@base.server_domain, id, attrs, :replace)
state.merge! attrs
end
def add(key, value)
- @base.sdb.put_attributes(@base.server_domain, name, { key => value })
+ @base.sdb.put_attributes(@base.server_domain, id, { key => value })
(state[key] ||= []) << value
end
def remove(key, value = nil)
if value
- @base.sdb.delete_attributes(@base.server_domain, name, key => value)
+ @base.sdb.delete_attributes(@base.server_domain, id, key => value)
state[key] - [value]
else
- @base.sdb.delete_attributes(@base.server_domain, name, [ key ])
+ @base.sdb.delete_attributes(@base.server_domain, id, [ key ])
state.delete(key)
end
end
def delete
group.delete_server(self) if group
- @base.sdb.delete_attributes(@base.server_domain, name)
+ @base.sdb.delete_attributes(@base.server_domain, id)
end
######## end simple DB access #######
def instance_type
@@ -337,11 +351,11 @@
ud = user_data(boot)
debug(ud)
result = @base.ec2.launch_instances(ami,
:instance_type => instance_type,
:availability_zone => config["availability_zone"],
- :key_name => config["key_name"],
+ :key_name => @base.key_name,
:group_ids => security_groups,
:user_data => ud).first
update "instance_id" => result[:aws_instance_id], "virgin" => false, "started_at" => Time.now.to_i
end
@@ -472,12 +486,13 @@
volume_id
end
def connect_ssh
wait_for_ssh
- system "chmod 600 #{group.keypair_file}"
- system "ssh -i #{group.keypair_file} #{config["user"]}@#{hostname}"
+ @base.keypair_file do |file|
+ system "ssh -i #{file} #{config["user"]}@#{hostname}"
+ end
end
def ec2_instance_type
ec2_instance[:aws_instance_type] rescue nil
end
@@ -486,20 +501,21 @@
hostname || config["state_ip"]
end
def reload
@base.reload_ec2_instances
- @base.servers_state.delete(name)
+ @base.servers_state.delete(id)
end
def user_data(judo_boot = nil)
<<USER_DATA
#!/bin/sh
export DEBIAN_FRONTEND="noninteractive"
export DEBIAN_PRIORITY="critical"
-export JUDO_ID='#{name}'
+export JUDO_ID='#{id}'
+export JUDO_NAME='#{name}'
export JUDO_DOMAIN='#{@base.domain}'
export JUDO_BOOT='#{judo_boot}'
export JUDO_DATA='#{data}'
export SECRET='#{secret}'
apt-get update
@@ -530,17 +546,26 @@
end
end
end
def snapshot(name)
- snap = @base.new_snapshot(name, self.name)
+ snap = @base.new_snapshot(name, id)
snap.create
+ snap
end
- def swapip(other)
+ def rename(newname)
+ raise JudoError, "Already a server with that name" if @base.servers.detect { |s| s.name == newname }
+ task("Renaming to #{newname}") do
+ update "name" => newname
+ end
+ end
+
+ def swap(other)
ip1 = elastic_ip
ip2 = other.elastic_ip
+
raise JudoError, "Server must have an elastic IP to swap" unless ip1 and ip2
task("Swapping Ip Addresses") do
@base.ec2.disassociate_address(ip1)
@base.ec2.disassociate_address(ip2)
@@ -548,9 +573,16 @@
@base.ec2.associate_address(instance_id, ip2)
@base.ec2.associate_address(other.instance_id, ip1)
update "elastic_ip" => ip2
other.update "elastic_ip" => ip1
+ end
+
+ task("Swapping Names") do
+ name1 = name
+ name2 = other.name
+ update "name" => name2
+ other.update "name" => name1
end
end
def <=>(s)
[group.name, name] <=> [s.group.name, s.name]