Class: LinuxAdmin::Disk

Inherits:
Object
  • Object
show all
Includes:
Common
Defined in:
lib/linux_admin/disk.rb

Constant Summary collapse

PARTED_FIELDS = 
[:id, :start_sector, :end_sector,
:size, :partition_type, :fs_type]

Constants included from Common

Common::BIN_DIRS

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Methods included from Common

#cmd, #cmd?, #run, #run!

Constructor Details

#initialize(args = {}) ⇒ Disk

Returns a new instance of Disk.



58
59
60
 
# File 'lib/linux_admin/disk.rb', line 58

def initialize(args = {})
  @path = args[:path]
end

Instance Attribute Details

#path ⇒ Object

Returns the value of attribute path.



11
12
13
 
# File 'lib/linux_admin/disk.rb', line 11

def path
  @path
end

Class Method Details

.local ⇒ Object 



52
53
54
55
56
 
# File 'lib/linux_admin/disk.rb', line 52

def self.local
  Dir.glob(['/dev/[vhs]d[a-z]', '/dev/xvd[a-z]']).collect do |d|
    Disk.new :path => d
  end
end

Instance Method Details

#clear! ⇒ Object 



173
174
175
176
177
178
179
180
181
182
 
# File 'lib/linux_admin/disk.rb', line 173

def clear!
  @partitions = []

  # clear partition table
  run!(cmd(:dd),
      :params => { 'if=' => '/dev/zero', 'of=' => @path,
                   'bs=' => 512, 'count=' => 1})

  self
end

#create_partition(partition_type, *args) ⇒ Object 



133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
 
# File 'lib/linux_admin/disk.rb', line 133

def create_partition(partition_type, *args)
  create_partition_table unless has_partition_table?

  start = finish = size = nil
  case args.length
  when 1 then
    start  = partitions.empty? ? 0 : partitions.last.end_sector
    size   = args.first
    finish = start + size

  when 2 then
    start  = args[0]
    finish = args[1]

  else
    raise ArgumentError, "must specify start/finish or size"
  end

  id = partitions.empty? ? 1 : (partitions.last.id + 1)
  options = parted_options_array('mkpart', '-a', 'opt', partition_type, start, finish)
  run!(cmd(:parted), :params => { nil => options})

  partition = Partition.new(:disk           => self,
                            :id             => id,
                            :start_sector   => start,
                            :end_sector     => finish,
                            :size           => size,
                            :partition_type => partition_type)
  partitions << partition
  partition
end

#create_partition_table(type = "msdos") ⇒ Object 



123
124
125
 
# File 'lib/linux_admin/disk.rb', line 123

def create_partition_table(type = "msdos")
  run!(cmd(:parted), :params => { nil => parted_options_array("mklabel", type)})
end

#create_partitions(partition_type, *args) ⇒ Object 



165
166
167
168
169
170
171
 
# File 'lib/linux_admin/disk.rb', line 165

def create_partitions(partition_type, *args)
  check_if_partitions_overlap(args)

  args.each { |arg|
    self.create_partition(partition_type, arg[:start], arg[:end])
  }
end

#has_partition_table? ⇒ Boolean

Returns:

  • (Boolean) 


127
128
129
130
131
 
# File 'lib/linux_admin/disk.rb', line 127

def has_partition_table?
  result = run(cmd(:parted), :params => { nil => parted_options_array("print")})

  result_indicates_partition_table?(result)
end

#partitions ⇒ Object 



76
77
78
79
80
81
 
# File 'lib/linux_admin/disk.rb', line 76

def partitions
  @partitions ||=
    parted_output.collect { |disk|
      partition_from_parted(disk)
    }
end

#size ⇒ Object 



62
63
64
65
66
67
68
69
70
71
72
73
74
 
# File 'lib/linux_admin/disk.rb', line 62

def size
  @size ||= begin
    size = nil
    out = run!(cmd(:fdisk), :params => {"-l" => nil}).output
    out.each_line do |l|
      /Disk #{path}: .*B, (\d+) bytes/.match(l) do |m|
        size = m[1].to_i
        break
      end
    end
    size
  end
end