server_maint 0.0.3 → 0.0.4

data/lib/cookbooks/aws/providers/ebs_volume.rb

@@ -0,0 +1,236 @@
+include Opscode::Aws::Ec2
+
+# Support whyrun
+def whyrun_supported?
+  true
+end
+
+action :create do
+  raise "Cannot create a volume with a specific id (EC2 chooses volume ids)" if new_resource.volume_id
+  if new_resource.snapshot_id =~ /vol/
+    new_resource.snapshot_id(find_snapshot_id(new_resource.snapshot_id))
+  end
+
+  nvid = volume_id_in_node_data
+  if nvid
+    # volume id is registered in the node data, so check that the volume in fact exists in EC2
+    vol = volume_by_id(nvid)
+    exists = vol && vol[:aws_status] != "deleting"
+    # TODO: determine whether this should be an error or just cause a new volume to be created. Currently erring on the side of failing loudly
+    raise "Volume with id #{nvid} is registered with the node but does not exist in EC2. To clear this error, remove the ['aws']['ebs_volume']['#{new_resource.name}']['volume_id'] entry from this node's data." unless exists
+  else
+    # Determine if there is a volume that meets the resource's specifications and is attached to the current
+    # instance in case a previous [:create, :attach] run created and attached a volume but for some reason was
+    # not registered in the node data (e.g. an exception is thrown after the attach_volume request was accepted
+    # by EC2, causing the node data to not be stored on the server)
+    if new_resource.device && (attached_volume = currently_attached_volume(instance_id, new_resource.device))
+      Chef::Log.debug("There is already a volume attached at device #{new_resource.device}")
+      compatible = volume_compatible_with_resource_definition?(attached_volume)
+      raise "Volume #{attached_volume[:aws_id]} attached at #{attached_volume[:aws_device]} but does not conform to this resource's specifications" unless compatible
+      Chef::Log.debug("The volume matches the resource's definition, so the volume is assumed to be already created")
+      converge_by("update the node data with volume id: #{attached_volume[:aws_id]}") do
+        node.set['aws']['ebs_volume'][new_resource.name]['volume_id'] = attached_volume[:aws_id]
+        node.save unless Chef::Config[:solo]
+      end
+    else
+      # If not, create volume and register its id in the node data
+      converge_by("create a volume with id=#{new_resource.snapshot_id} size=#{new_resource.size} availability_zone=#{new_resource.availability_zone} and update the node data with created volume's id") do
+        nvid = create_volume(new_resource.snapshot_id, new_resource.size, new_resource.availability_zone, new_resource.timeout)
+        node.set['aws']['ebs_volume'][new_resource.name]['volume_id'] = nvid
+        node.save unless Chef::Config[:solo]
+      end
+    end
+  end
+end
+
+action :attach do
+  vol = determine_volume
+
+  if vol[:aws_status] == "in-use"
+    if vol[:aws_instance_id] != instance_id
+      raise "Volume with id #{vol[:aws_id]} exists but is attached to instance #{vol[:aws_instance_id]}"
+    else
+      Chef::Log.debug("Volume is already attached")
+    end
+  else
+    converge_by("attach the volume with aws_id=#{vol[:aws_id]} id=#{instance_id} device=#{new_resource.device} and update the node data with created volume's id") do
+      # attach the volume and register its id in the node data
+      attach_volume(vol[:aws_id], instance_id, new_resource.device, new_resource.timeout)
+      node.set['aws']['ebs_volume'][new_resource.name]['volume_id'] = vol['aws_id']
+      node.save unless Chef::Config[:solo]
+    end
+  end
+end
+
+action :detach do
+  vol = determine_volume
+  return if vol[:aws_instance_id] != instance_id
+  converge_by("detach volume with id: #{vol[:aws_id]}") do
+    detach_volume(vol[:aws_id], new_resource.timeout)
+  end
+end
+
+action :snapshot do
+  vol = determine_volume
+  converge_by("would create a snapshot for volume: #{vol[:aws_id]}") do
+    snapshot = ec2.create_snapshot(vol[:aws_id],new_resource.description)
+    Chef::Log.info("Created snapshot of #{vol[:aws_id]} as #{snapshot[:aws_id]}")
+  end
+end
+
+action :prune do
+  vol = determine_volume
+  old_snapshots = Array.new
+  Chef::Log.info "Checking for old snapshots"
+  ec2.describe_snapshots.sort { |a,b| b[:aws_started_at] <=> a[:aws_started_at] }.each do |snapshot|
+    if snapshot[:aws_volume_id] == vol[:aws_id]
+      Chef::Log.info "Found old snapshot #{snapshot[:aws_id]} (#{snapshot[:aws_volume_id]}) #{snapshot[:aws_started_at]}"
+      old_snapshots << snapshot
+    end 
+  end
+  if old_snapshots.length > new_resource.snapshots_to_keep 
+    old_snapshots[new_resource.snapshots_to_keep, old_snapshots.length].each do |die|
+      converge_by("delete snapshot with id: #{die[:aws_id]}") do
+        Chef::Log.info "Deleting old snapshot #{die[:aws_id]}"
+        ec2.delete_snapshot(die[:aws_id])
+      end
+    end
+  end
+end
+
+private
+
+def volume_id_in_node_data
+  begin
+    node['aws']['ebs_volume'][new_resource.name]['volume_id']
+  rescue NoMethodError => e
+    nil
+  end
+end
+
+# Pulls the volume id from the volume_id attribute or the node data and verifies that the volume actually exists
+def determine_volume
+  vol = currently_attached_volume(instance_id, new_resource.device)
+  vol_id = new_resource.volume_id || volume_id_in_node_data || ( vol ? vol[:aws_id] : nil )
+  raise "volume_id attribute not set and no volume id is set in the node data for this resource (which is populated by action :create) and no volume is attached at the device" unless vol_id
+
+  # check that volume exists
+  vol = volume_by_id(vol_id)
+  raise "No volume with id #{vol_id} exists" unless vol
+
+  vol
+end
+
+# Retrieves information for a volume
+def volume_by_id(volume_id)
+  ec2.describe_volumes.find{|v| v[:aws_id] == volume_id}
+end
+
+# Returns the volume that's attached to the instance at the given device or nil if none matches
+def currently_attached_volume(instance_id, device)
+  ec2.describe_volumes.find{|v| v[:aws_instance_id] == instance_id && v[:aws_device] == device}
+end
+
+# Returns true if the given volume meets the resource's attributes
+def volume_compatible_with_resource_definition?(volume)
+  if new_resource.snapshot_id =~ /vol/
+    new_resource.snapshot_id(find_snapshot_id(new_resource.snapshot_id))
+  end
+  (new_resource.size.nil? || new_resource.size == volume[:aws_size]) &&
+  (new_resource.availability_zone.nil? || new_resource.availability_zone == volume[:zone]) &&
+  (new_resource.snapshot_id == volume[:snapshot_id])
+end
+
+# Creates a volume according to specifications and blocks until done (or times out)
+def create_volume(snapshot_id, size, availability_zone, timeout)
+  availability_zone ||= instance_availability_zone
+  nv = ec2.create_volume(snapshot_id, size, availability_zone)
+  Chef::Log.debug("Created new volume #{nv[:aws_id]}#{snapshot_id ? " based on #{snapshot_id}" : ""}")
+
+  # block until created
+  begin
+    Timeout::timeout(timeout) do
+      while true
+        vol = volume_by_id(nv[:aws_id])
+        if vol && vol[:aws_status] != "deleting"
+          if ["in-use", "available"].include?(vol[:aws_status])
+            Chef::Log.info("Volume #{nv[:aws_id]} is available")
+            break
+          else
+            Chef::Log.debug("Volume is #{vol[:aws_status]}")
+          end
+          sleep 3
+        else
+          raise "Volume #{nv[:aws_id]} no longer exists"
+        end
+      end
+    end
+  rescue Timeout::Error
+    raise "Timed out waiting for volume creation after #{timeout} seconds"
+  end
+
+  nv[:aws_id]
+end
+
+# Attaches the volume and blocks until done (or times out)
+def attach_volume(volume_id, instance_id, device, timeout)
+  Chef::Log.debug("Attaching #{volume_id} as #{device}")
+  ec2.attach_volume(volume_id, instance_id, device)
+
+  # block until attached
+  begin
+    Timeout::timeout(timeout) do
+      while true
+        vol = volume_by_id(volume_id)
+        if vol && vol[:aws_status] != "deleting"
+          if vol[:aws_attachment_status] == "attached"
+            if vol[:aws_instance_id] == instance_id
+              Chef::Log.info("Volume #{volume_id} is attached to #{instance_id}")
+              break
+            else
+              raise "Volume is attached to instance #{vol[:aws_instance_id]} instead of #{instance_id}"
+            end
+          else
+            Chef::Log.debug("Volume is #{vol[:aws_status]}")
+          end
+          sleep 3
+        else
+          raise "Volume #{volume_id} no longer exists"
+        end
+      end
+    end
+  rescue Timeout::Error
+    raise "Timed out waiting for volume attachment after #{timeout} seconds"
+  end
+end
+
+# Detaches the volume and blocks until done (or times out)
+def detach_volume(volume_id, timeout)
+  Chef::Log.debug("Detaching #{volume_id}")
+  vol = volume_by_id(volume_id)
+  orig_instance_id = vol[:aws_instance_id]
+  ec2.detach_volume(volume_id)
+
+  # block until detached
+  begin
+    Timeout::timeout(timeout) do
+      while true
+        vol = volume_by_id(volume_id)
+        if vol && vol[:aws_status] != "deleting"
+          if vol[:aws_instance_id] != orig_instance_id
+            Chef::Log.info("Volume detached from #{orig_instance_id}")
+            break
+          else
+            Chef::Log.debug("Volume: #{vol.inspect}")
+          end
+        else
+          Chef::Log.debug("Volume #{volume_id} no longer exists")
+          break
+        end
+        sleep 3
+      end
+    end
+  rescue Timeout::Error
+    raise "Timed out waiting for volume detachment after #{timeout} seconds"
+  end
+end

data/lib/cookbooks/aws/providers/elastic_ip.rb

@@ -0,0 +1,90 @@
+include Opscode::Aws::Ec2
+
+# Support whyrun
+def whyrun_supported?
+  true
+end
+
+action :associate do
+  addr = address(new_resource.ip)
+
+  if addr.nil?
+    raise "Elastic IP #{new_resource.ip} does not exist"
+  elsif addr[:instance_id] == instance_id
+    Chef::Log.debug("Elastic IP #{new_resource.ip} is already attached to the instance")
+  else
+    converge_by("attach Elastic IP #{new_resource.ip} to the instance") do
+      Chef::Log.info("Attaching Elastic IP #{new_resource.ip} to the instance")
+      attach(new_resource.ip, new_resource.timeout)
+    end
+  end
+end
+
+action :disassociate do
+  addr = address(new_resource.ip)
+
+  if addr.nil?
+    Chef::Log.debug("Elastic IP #{new_resource.ip} does not exist, so there is nothing to detach")
+  elsif addr[:instance_id] != instance_id
+    Chef::Log.debug("Elastic IP #{new_resource.ip} is already detached from the instance")
+  else
+    converge_by("detach Elastic IP #{new_resource.ip} from the instance") do
+      Chef::Log.info("Detaching Elastic IP #{new_resource.ip} from the instance")
+      detach(new_resource.ip, new_resource.timeout)
+    end
+  end
+end
+
+private
+
+def address(ip)
+  ec2.describe_addresses.find{|a| a[:public_ip] == ip}
+end
+
+def attach(ip, timeout)
+  ec2.associate_address(instance_id, ip)
+
+  # block until attached
+  begin
+    Timeout::timeout(timeout) do
+      while true
+        addr = address(ip)
+        if addr.nil?
+          raise "Elastic IP has been deleted while waiting for attachment"
+        elsif addr[:instance_id] == instance_id
+          Chef::Log.debug("Elastic IP is attached to this instance")
+          break
+        else
+          Chef::Log.debug("Elastic IP is currently attached to #{addr[:instance_id]}")
+        end
+        sleep 3
+      end
+    end
+  rescue Timeout::Error
+    raise "Timed out waiting for attachment after #{timeout} seconds"
+  end
+end
+
+def detach(ip, timeout)
+  ec2.disassociate_address(ip)
+
+  # block until detached
+  begin
+    Timeout::timeout(timeout) do
+      while true
+        addr = address(ip)
+        if addr.nil?
+          Chef::Log.debug("Elastic IP has been deleted while waiting for detachment")
+        elsif addr[:instance_id] != instance_id
+          Chef::Log.debug("Elastic IP is detached from this instance")
+          break
+        else
+          Chef::Log.debug("Elastic IP is still attached")
+        end
+        sleep 3
+      end
+    end
+  rescue Timeout::Error
+    raise "Timed out waiting for detachment after #{timeout} seconds"
+  end
+end

data/lib/cookbooks/aws/providers/elastic_lb.rb

@@ -0,0 +1,24 @@
+include Opscode::Aws::Ec2
+
+action :register do
+  converge_by("add the node #{new_resource.name} to ELB") do
+    Chef::Log.info("Adding node to ELB #{new_resource.name}")
+    elb.register_instances_with_load_balancer(new_resource.name, instance_id)
+  end
+end
+
+action :deregister do
+  converge_by("remove the node #{new_resource.name} from ELB") do
+    Chef::Log.info("Removing node from ELB #{new_resource.name}")
+    elb.deregister_instances_with_load_balancer(new_resource.name, instance_id)
+  end
+end
+
+private
+
+def elb
+  region = instance_availability_zone
+  region = region[0, region.length-1]
+  @@elb ||= RightAws::ElbInterface.new(new_resource.aws_access_key, new_resource.aws_secret_access_key, { :logger => Chef::Log, :region => region })
+end
+

data/lib/cookbooks/aws/providers/resource_tag.rb

@@ -0,0 +1,93 @@
+include Opscode::Aws::Ec2
+
+action :add do
+
+  unless @new_resource.resource_id
+    resource_id = @new_resource.name
+  else
+    resource_id = @new_resource.resource_id
+  end
+
+  @new_resource.tags.each do |k,v|
+    unless @current_resource.tags.keys.include?(k)
+      converge_by("add tag '#{k}' with value '#{v}' on resource #{resource_id}") do
+        ec2.create_tags(resource_id, { k => v })
+        Chef::Log.info("AWS: Added tag '#{k}' with value '#{v}' on resource #{resource_id}")
+      end
+    else
+      Chef::Log.debug("AWS: Resource #{resource_id} already has a tag with key '#{k}', will not add tag '#{k}' => '#{v}'")
+    end
+  end
+end
+
+action :update do
+  unless @new_resource.resource_id
+    resource_id = @new_resource.name
+  else
+    resource_id = @new_resource.resource_id
+  end
+
+  updated_tags = @current_resource.tags.merge(@new_resource.tags)
+  unless updated_tags.eql?(@current_resource.tags)
+    converge_by("Updating the following tags for resource #{resource_id}: " + updated_tags.inspect) do 
+      Chef::Log.info("AWS: Updating the following tags for resource #{resource_id}: " + updated_tags.inspect)
+      ec2.create_tags(resource_id, updated_tags)
+    end
+  else
+    Chef::Log.debug("AWS: Tags for resource #{resource_id} are unchanged")
+  end
+end
+
+action :remove do
+  unless @new_resource.resource_id
+    resource_id = @new_resource.name
+  else
+    resource_id = @new_resource.resource_id
+  end
+
+  tags_to_delete = @new_resource.tags.keys
+
+  tags_to_delete.each do |key|
+    if @current_resource.tags.keys.include?(key) and @current_resource.tags[key] == @new_resource.tags[key]
+      converge_by("delete tag '#{key}' on resource #{resource_id} with value '#{@current_resource.tags[key]}'") do
+        ec2.delete_tags(resource_id, {key => @new_resource.tags[key]})
+        Chef::Log.info("AWS: Deleted tag '#{key}' on resource #{resource_id} with value '#{@current_resource.tags[key]}'")
+      end
+    end
+  end
+end
+
+action :force_remove do
+  unless @new_resource.resource_id
+    resource_id = @new_resource.name
+  else
+    resource_id = @new_resource.resource_id
+  end
+
+  @new_resource.tags.keys do |key|
+    if @current_resource.tags.keys.include?(key)
+      converge_by("AWS: Deleted tag '#{key}' on resource #{resource_id} with value '#{@current_resource.tags[key]}'") do
+        ec2.delete_tags(resource_id, key)
+        Chef::Log.info("AWS: Deleted tag '#{key}' on resource #{resource_id} with value '#{@current_resource.tags[key]}'")
+      end
+    end
+  end
+end
+
+def load_current_resource
+  @current_resource = Chef::Resource::AwsResourceTag.new(@new_resource.name)
+  @current_resource.name(@new_resource.name)
+  unless @new_resource.resource_id
+    @current_resource.resource_id(@new_resource.name)
+  else
+    @current_resource.resource_id(@new_resource.resource_id)
+  end
+
+  @current_resource.tags(Hash.new)
+
+  ec2.describe_tags(:filters => { 'resource-id' => @current_resource.resource_id }).map {
+    |tag| @current_resource.tags[tag[:key]] = tag[:value] 
+  }
+
+  @current_resource
+end

data/lib/cookbooks/aws/recipes/default.rb

@@ -0,0 +1,25 @@
+#
+# Cookbook Name:: aws
+# Recipe:: default
+#
+# Copyright 2008-2009, Opscode, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+chef_gem "right_aws" do
+  version node['aws']['right_aws_version']
+  action :install
+end
+
+require 'right_aws'

data/lib/cookbooks/aws/resources/ebs_volume.rb

@@ -0,0 +1,17 @@
+actions :create, :attach, :detach, :snapshot, :prune
+
+attribute :aws_access_key,        :kind_of => String
+attribute :aws_secret_access_key, :kind_of => String
+attribute :size,                  :kind_of => Integer
+attribute :snapshot_id,           :kind_of => String
+attribute :availability_zone,     :kind_of => String
+attribute :device,                :kind_of => String
+attribute :volume_id,             :kind_of => String
+attribute :description,           :kind_of => String
+attribute :timeout,               :default => 3*60 # 3 mins, nil or 0 for no timeout
+attribute :snapshots_to_keep,     :default => 2
+
+def initialize(*args)
+  super
+  @action = :create
+end

data/lib/cookbooks/aws/resources/elastic_ip.rb

@@ -0,0 +1,11 @@
+actions :associate, :disassociate
+
+attribute :aws_access_key,        :kind_of => String
+attribute :aws_secret_access_key, :kind_of => String
+attribute :ip,                    :kind_of => String
+attribute :timeout,               :default => 3*60 # 3 mins, nil or 0 for no timeout
+
+def initialize(*args)
+  super
+  @action = :associate
+end

data/lib/cookbooks/aws/resources/elastic_lb.rb

@@ -0,0 +1,10 @@
+actions :register, :deregister
+
+attribute :aws_access_key,        :kind_of => String
+attribute :aws_secret_access_key, :kind_of => String
+attribute :name,                  :kind_of => String
+
+def initialize(*args)
+  super
+  @action = :register
+end

data/lib/cookbooks/aws/resources/resource_tag.rb

@@ -0,0 +1,11 @@
+def initialize(*args)
+  super
+  @action = :update
+end
+
+actions :add, :update, :remove, :force_remove
+
+attribute :aws_access_key, :kind_of => String, :required => true
+attribute :aws_secret_access_key, :kind_of => String, :required => true
+attribute :resource_id,  :kind_of => [ String, Array ], :regex => /(i|snap|vol)-[a-zA-Z0-9]+/
+attribute :tags, :kind_of => Hash, :required => true

data/lib/cookbooks/database/.gitignore

@@ -0,0 +1 @@
+*.sw[op]

data/lib/cookbooks/database/CHANGELOG.md

@@ -0,0 +1,51 @@
+## v1.3.6:
+
+* [COOK-1688] - fix typo in readme and add amazon linux to supported
+  platforms
+
+## v1.3.4:
+
+* [COOK-1561] - depend on mysql 1.3.0+ explicitly
+* depend on postgresql 1.0.0 explicitly
+
+## v1.3.2:
+
+* Update the version for release (oops)
+
+## v1.3.0:
+
+* [COOK-932] - Add mysql recipe to conveniently include mysql::ruby
+* [COOK-1228] - database resource should be able to execute scripts on disk
+* [COOK-1291] - make the snapshot retention policy less confusing
+* [COOK-1401] - Allow to specify the collation of new databases
+* [COOK-1534] - Add postgresql recipe to conveniently include postgresql::ruby
+
+## v1.2.0:
+
+* [COOK-970] - workaround for disk [re]naming on ubuntu 11.04+
+* [COOK-1085] - check RUBY_VERSION and act accordingly for role
+* [COOK-749] - localhost should be a string in snapshot recipe
+
+## v1.1.4:
+
+* [COOK-1062] - Databases: Postgres exists should close connection
+
+## v1.1.2:
+
+* [COOK-975] - Change arg='DEFAULT' to arg=nil, :default => 'DEFAULT'
+* [COOK-964] - Add parentheses around connection hash in example
+
+## v1.1.0
+
+* [COOK-716] - providers for PostgreSQL
+
+## v1.0.0
+
+* [COOK-683] - added `database` and `database_user` resources
+* [COOK-684] - MySQL providers
+* [COOK-685] - SQL Server providers
+* refactored - `database::master` and `database::snapshot` recipes to leverage new resources
+
+## v0.99.1
+
+* Use Chef 0.10's `node.chef_environment` instead of `node['app_environment']`.

data/lib/cookbooks/database/CONTRIBUTING

@@ -0,0 +1,29 @@
+If you would like to contribute, please open a ticket in JIRA:
+
+* http://tickets.opscode.com
+
+Create the ticket in the COOK project and use the cookbook name as the
+component.
+
+For all code contributions, we ask that contributors sign a
+contributor license agreement (CLA). Instructions may be found here:
+
+* http://wiki.opscode.com/display/chef/How+to+Contribute
+
+When contributing changes to individual cookbooks, please do not
+modify the version number in the metadata.rb. Also please do not
+update the CHANGELOG.md for a new version. Not all changes to a
+cookbook may be merged and released in the same versions. Opscode will
+handle the version updates during the release process. You are welcome
+to correct typos or otherwise make updates to documentation in the
+README.
+
+If a contribution adds new platforms or platform versions, indicate
+such in the body of the commit message(s), and update the relevant
+COOK ticket. When writing commit messages, it is helpful for others if
+you indicate the COOK ticket. For example:
+
+    git commit -m '[COOK-1041] Updated pool resource to correctly delete.'
+
+In the ticket itself, it is also helpful if you include log output of
+a successful Chef run, but this is not absolutely required.