Skip to content

Instantly share code, notes, and snippets.

Embed
What would you like to do?
Ebs raid mounting. Links to this jira issue http://tickets.opscode.com/browse/CHEF-2275
include Opscode::Aws::Ec2
#Auto locates and attached ebs devices based on the data bag they reside in. The following test cases need to be performed
# Create multiple resources with new node: PASS
#
# Re-attach multiple resources after a reboot: PASS
#
# Create resources across 2 runs. First run creates first raid set, second run re-attaches then creates: PASS
#
# Re-attach a different nodes data after terminating the original creator: Partial pass. Does not rename data bag correctly
# Author: Todd Nine
action :auto_attach do
Chef::Log.info("Executing the autolocate task")
#Make sure the mdadm package is installed
package "mdadm" do
action :install
end
package "xfsprogs" do
action :install
end
#we're done we successfully located what we needed
if !locate_and_mount(@new_resource.mount_point)
#If we get here, we couldn't auto attach, nor re-allocate an existing set of disks to ourselves. Auto create the md devices
#Find our first raid device
number=0
dir = "/dev/md#{number}"
#TODO, this won't work with more than 10 md devices
begin
dir = "/dev/md#{number}"
Chef::Log.info("md pre trim #{dir}")
number +=1
end while ::File.exists?(dir)
dir = dir[5, dir.length]
Chef::Log.debug("raid device is #{dir}")
sd_dev = "sdh"
begin
sd_dev = sd_dev.next
base_device = "/dev/#{sd_dev}1"
Chef::Log.info("dev pre trim #{base_device}")
end while ::File.exists?(base_device)
Chef::Log.debug("sd device is #{sd_dev}")
create_raid_disks(@new_resource.mount_point, dir, sd_dev, @new_resource.disk_count, @new_resource.disk_size)
@new_resource.updated_by_last_action(true)
end
end
private
#Attempt to find an unused data bag and mount all the EBS volumes to our system
def locate_and_mount(mount_path )
if node[:aws].nil? || node[:aws][:raid].nil? || node[:aws][:raid][mount_path].nil?
Chef::Log.info("No mount point found '#{mount_path}' for node")
return false;
end
raid_dev = node[:aws][:raid][mount_path][:raid_dev]
raid_dev = "/dev/#{raid_dev}"
Chef::Log.info("Raid device is #{raid_dev} and mount path is #{mount_path}")
assemble_raid(raid_dev, mount_path)
#Now mount the drive
mount_device(raid_dev, mount_path)
return true
end
##
#Assembles the raid if it doesn't already exist
##
def assemble_raid(raid_dev, mount_path)
#D
if ::File.exists?(raid_dev)
Chef::Log.info("Device #{raid_dev} exists skipping")
return
end
Chef::Log.info("Raid device #{raid_dev} does not exist re-assembling")
device_vol_map = node[:aws][:raid][mount_path][:devices]
Chef::Log.debug("Devices for mount #{mount_path} are #{device_vol_map}")
device_string = ""
device_vol_map.keys.sort.each do |dev_device|
attach_volume(dev_device, device_vol_map[dev_device])
device_string += "/dev/#{dev_device} "
end
#Wait until all volumes are mounted
ruby_block "wait" do
block do
true
end
end
#Wait until all volumes are mounted
ruby_block "wait" do
block do
Chef::Log.info("sleeping 10 seconds until EBS volumes have re-attached")
sleep 10
end
end
#Now that attach is done we re-build the md device
execute "re-attaching raid device" do
command "mdadm --assemble #{raid_dev} #{device_string}"
creates raid_dev
not_if "test -d #{raid_dev}"
# notifies :run, "ruby_block[setchanged]", :immediately
end
end
def mount_device(raid_dev, mnt_point)
#Create the mount point
directory mnt_point do
owner "root"
group "nogroup"
mode 0755
recursive true
action :create
not_if "test -d #{mnt_point}"
# notifies :run, "ruby_block[setchanged]", :immediately
end
#Mount the device
mount mnt_point do
device raid_dev
fstype "xfs"
options "rw,noatime,inode64"
action :mount
# notifies :run, "ruby_block[setchanged]", :immediately
end
end
#Attach all existing ami instances if they exist on this node, if not, we want an error to occur Detects disk from node information
def attach_volume(disk_dev, volume_id)
disk_dev_path = "/dev/#{disk_dev}"
aws = data_bag_item("deployment", "aws")
Chef::Log.info("Attaching existing ebs volume id #{volume_id} for device #{disk_dev_path}")
aws_ebs_volume "#{disk_dev_path}" do
aws_access_key aws['accesskey']
aws_secret_access_key aws['secretkey']
device disk_dev_path
name disk_dev
volume_id volume_id
action [:attach]
provider "aws_ebs_volume"
end
end
#Mount point for where to mount I.E /mnt/filesystem
#Raid dev. I.E. md0
#Diskset I.E sdi (which creates sdi1-sdi<n>
#Raid size. The total size of the array
def create_raid_disks(mnt_point, raid_dev, disk_dev, num_disks, disk_size)
#Create the mount point data bag
devices = {}
#For each volume add information to the mount metadata
(1..num_disks).each do |i|
disk_dev_path = "#{disk_dev}#{i}"
aws = data_bag_item("deployment", "aws")
aws_ebs_volume "#{disk_dev_path}" do
aws_access_key aws['accesskey']
aws_secret_access_key aws['secretkey']
size disk_size
device "/dev/#{disk_dev_path}"
name disk_dev_path
action [:create, :attach]
provider "aws_ebs_volume"
#set up our data bag info
devices[disk_dev_path] = "pending"
Chef::Log.info("creating ebs volume for device #{disk_dev_path} with size #{disk_size}")
end
end
devices_string = ""
#Blocking task
devices.keys.sort.each do |k|
devices_string += "/dev/#{k} "
end
Chef::Log.debug("finsihed sorting devices #{devices_string}")
Chef::Log.debug("sleeping 10 seconds to let drives attach")
sleep 10
#Create the raid device on our system
execute "creating raid device" do
Chef::Log.info("creating raid device /dev/#{raid_dev} with raid devices #{devices_string}")
command "mdadm --create /dev/#{raid_dev} --level=0 --raid-devices=#{devices.size} #{devices_string}"
creates "/dev/#{raid_dev}"
end
#Format the device
execute "formatting device" do
command "mkfs.xfs /dev/#{raid_dev}"
only_if "xfs_admin -l /dev/#{raid_dev} 2>&1 | grep -qx 'xfs_admin: /dev/#{raid_dev} is not a valid XFS filesystem (unexpected SB magic number 0x00000000)'"
end
#Mount the device
mount_device("/dev/#{raid_dev}", mnt_point)
#Not invoked until the volumes have been successfully created and attached
ruby_block "databagsetup" do
block do
Chef::Log.info("finished creating disks")
devices.each_pair do |key, value|
value = node[:aws][:ebs_volume][key][:volume_id]
devices[key] = value
Chef::Log.info("value is #{value}")
end
#Assemble all the data bag meta data
mount_meta = {
"raid_dev" => raid_dev,
"devices" => devices
}
raid_map = node[:aws][:raid]
if raid_map.nil?
node[:aws][:raid] = {}
end
node[:aws][:raid][mnt_point] = mount_meta
node.save
end
end
#Now format and create the device
end
include_recipe "aws"
#Create 10 gig raid from 10 1G drives
aws_ebs_raid "createzkdir" do
mount_point node[:zookeeper][:data_dir]
disk_count 10
disk_size 1
action [:auto_attach]
notifies :restart, resources(:service => "zookeeper")
end
#Installation
#copy to into aws/providers
#Add this to the dependencies
depends "aws"
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment