← Back to branch summary

~gandelman-a/ubuntu/precise/facter/merge922788

« back to all changes in this revision

Viewing changes to lib/facter/memory.rb

  • Committer: Package Import Robot
  • Author(s): Adam Gandelman
  • Date: 2011-11-10 10:11:05 UTC
  • mfrom: (1.1.11) (3.1.11 sid)
  • Revision ID: package-import@ubuntu.com-20111110101105-w7xr4ndfndpdxljx
Tags: 1.6.2-1ubuntu1
https://launchpad.net/bugs/888671
https://launchpad.net/bugs/408402
* Merge from Debian testing (LP: #888671).  Remaining changes:
  - debian/rules: use what we had in natty; we don't want ruby-pkg-tools
    in main. (LP: #408402)
  - debian/control: Continue using ruby + libopenssl-ruby as Build-Depends
    even tho Debian has moved to gem2deb (not in main). Move ruby-json to
    Suggests.
* debian/rules: Use dh_prep instead of dh_clean, add build-arch + build-indep
  targets
* debian/control: Update debhelper Build-Depends to 8, make binary package
  depend on ruby1.8 explicitly.

Show diffs side-by-side

added added

removed removed

Lines of Context:
lib/facter/memory.rb
29
29
    :SwapSize   => "SwapTotal",
30
30
    :SwapFree   => "SwapFree"
31
31
}.each do |fact, name|
32
 
    Facter.add(fact) do
33
 
        confine :kernel => [ :linux, :"gnu/kfreebsd" ]
34
 
        setcode do
35
 
            Facter::Memory.meminfo_number(name)
36
 
        end
 
32
  Facter.add(fact) do
 
33
    confine :kernel => [ :linux, :"gnu/kfreebsd" ]
 
34
    setcode do
 
35
      Facter::Memory.meminfo_number(name)
37
36
    end
 
37
  end
38
38
end
39
39
 
40
40
Facter.add("SwapSize") do
41
 
    confine :kernel => :Darwin
42
 
    setcode do
 
41
  confine :kernel => :Darwin
 
42
  setcode do
43
43
    swap = Facter::Util::Resolution.exec('sysctl vm.swapusage')
44
44
    swaptotal = 0
45
45
    if swap =~ /total = (\S+)/ then swaptotal = $1; end
46
 
      swaptotal
47
 
    end
 
46
    swaptotal
 
47
  end
48
48
end
49
49
 
50
50
Facter.add("SwapFree") do
51
 
    confine :kernel => :Darwin
52
 
    setcode do
 
51
  confine :kernel => :Darwin
 
52
  setcode do
53
53
    swap = Facter::Util::Resolution.exec('sysctl vm.swapusage')
54
54
    swapfree = 0
55
55
    if swap =~ /free = (\S+)/ then swapfree = $1; end
56
 
      swapfree
57
 
    end
 
56
    swapfree
 
57
  end
58
58
end
59
59
 
60
60
Facter.add("SwapEncrypted") do
61
 
    confine :kernel => :Darwin
62
 
    setcode do
 
61
  confine :kernel => :Darwin
 
62
  setcode do
63
63
    swap = Facter::Util::Resolution.exec('sysctl vm.swapusage')
64
64
    encrypted = false
65
65
    if swap =~ /\(encrypted\)/ then encrypted = true; end
66
 
      encrypted
67
 
    end
 
66
    encrypted
 
67
  end
68
68
end
69
69
 
70
70
if Facter.value(:kernel) == "AIX" and Facter.value(:id) == "root"
71
 
    swap = Facter::Util::Resolution.exec('swap -l')
72
 
    swapfree, swaptotal = 0, 0
73
 
    swap.each_line do |dev|
74
 
      if dev =~ /^\/\S+\s.*\s+(\S+)MB\s+(\S+)MB/
75
 
        swaptotal += $1.to_i
76
 
        swapfree  += $2.to_i
77
 
      end
78
 
    end
79
 
 
80
 
    Facter.add("SwapSize") do
81
 
        confine :kernel => :aix
82
 
        setcode do
83
 
            Facter::Memory.scale_number(swaptotal.to_f,"MB")
84
 
        end
85
 
    end
86
 
 
87
 
    Facter.add("SwapFree") do
88
 
        confine :kernel => :aix
89
 
        setcode do
90
 
            Facter::Memory.scale_number(swapfree.to_f,"MB")
91
 
        end
92
 
    end
 
71
  swap = Facter::Util::Resolution.exec('swap -l')
 
72
  swapfree, swaptotal = 0, 0
 
73
  swap.each_line do |dev|
 
74
    if dev =~ /^\/\S+\s.*\s+(\S+)MB\s+(\S+)MB/
 
75
      swaptotal += $1.to_i
 
76
      swapfree  += $2.to_i
 
77
    end
 
78
  end
 
79
 
 
80
  Facter.add("SwapSize") do
 
81
    confine :kernel => :aix
 
82
    setcode do
 
83
      Facter::Memory.scale_number(swaptotal.to_f,"MB")
 
84
    end
 
85
  end
 
86
 
 
87
  Facter.add("SwapFree") do
 
88
    confine :kernel => :aix
 
89
    setcode do
 
90
      Facter::Memory.scale_number(swapfree.to_f,"MB")
 
91
    end
 
92
  end
93
93
end
94
94
 
95
95
if Facter.value(:kernel) == "OpenBSD"
96
 
    swap = Facter::Util::Resolution.exec('swapctl -l | sed 1d')
97
 
    swapfree, swaptotal = 0, 0
98
 
    swap.each_line do |dev|
99
 
        if dev =~ /^\S+\s+(\S+)\s+\S+\s+(\S+)\s+.*$/
100
 
            swaptotal += $1.to_i
101
 
            swapfree  += $2.to_i
102
 
        end
103
 
    end
104
 
 
105
 
    Facter.add("SwapSize") do
106
 
        confine :kernel => :openbsd
107
 
        setcode do
108
 
            Facter::Memory.scale_number(swaptotal.to_f,"kB")
109
 
        end
110
 
    end
111
 
 
112
 
    Facter.add("SwapFree") do
113
 
        confine :kernel => :openbsd
114
 
        setcode do
115
 
            Facter::Memory.scale_number(swapfree.to_f,"kB")
116
 
        end
117
 
    end
118
 
 
119
 
    Facter::Memory.vmstat_find_free_memory()
120
 
 
121
 
    Facter.add("MemoryTotal") do
122
 
        confine :kernel => :openbsd
123
 
        memtotal = Facter::Util::Resolution.exec("sysctl hw.physmem | cut -d'=' -f2")
124
 
        setcode do
125
 
            Facter::Memory.scale_number(memtotal.to_f,"")
126
 
        end
127
 
    end
 
96
  swap = Facter::Util::Resolution.exec('swapctl -s')
 
97
  swapfree, swaptotal = 0, 0
 
98
  if swap =~ /^total: (\d+)k bytes allocated = \d+k used, (\d+)k available$/
 
99
    swaptotal = $1.to_i
 
100
    swapfree  = $2.to_i
 
101
  end
 
102
 
 
103
  Facter.add("SwapSize") do
 
104
    confine :kernel => :openbsd
 
105
    setcode do
 
106
      Facter::Memory.scale_number(swaptotal.to_f,"kB")
 
107
    end
 
108
  end
 
109
 
 
110
  Facter.add("SwapFree") do
 
111
    confine :kernel => :openbsd
 
112
    setcode do
 
113
      Facter::Memory.scale_number(swapfree.to_f,"kB")
 
114
    end
 
115
  end
 
116
 
 
117
  Facter::Memory.vmstat_find_free_memory()
 
118
 
 
119
  Facter.add("MemoryTotal") do
 
120
    confine :kernel => :openbsd
 
121
    memtotal = Facter::Util::Resolution.exec("sysctl hw.physmem | cut -d'=' -f2")
 
122
    setcode do
 
123
      Facter::Memory.scale_number(memtotal.to_f,"")
 
124
    end
 
125
  end
128
126
end
129
127
 
130
128
if Facter.value(:kernel) == "Darwin"
131
 
    swap = Facter::Util::Resolution.exec('sysctl vm.swapusage')
132
 
    swapfree, swaptotal = 0, 0
133
 
    unless swap.empty?
134
 
        # Parse the line:
135
 
        # vm.swapusage: total = 128.00M  used = 0.37M  free = 127.63M  (encrypted)
136
 
        if swap =~ /total\s=\s(\S+)\s+used\s=\s(\S+)\s+free\s=\s(\S+)\s/
137
 
            swaptotal += $1.to_i
138
 
            swapfree  += $3.to_i
139
 
        end
140
 
    end
141
 
 
142
 
    Facter.add("SwapSize") do
143
 
        confine :kernel => :Darwin
144
 
        setcode do
145
 
            Facter::Memory.scale_number(swaptotal.to_f,"MB")
146
 
        end
147
 
    end
148
 
 
149
 
    Facter.add("SwapFree") do
150
 
        confine :kernel => :Darwin
151
 
        setcode do
152
 
            Facter::Memory.scale_number(swapfree.to_f,"MB")
153
 
        end
154
 
    end
155
 
 
156
 
    Facter::Memory.vmstat_darwin_find_free_memory()
157
 
 
158
 
    Facter.add("MemoryTotal") do
159
 
        confine :kernel => :Darwin
160
 
        memtotal = Facter::Util::Resolution.exec("sysctl hw.memsize | cut -d':' -f2")
161
 
        setcode do
162
 
            Facter::Memory.scale_number(memtotal.to_f,"")
163
 
        end
164
 
    end
 
129
  swap = Facter::Util::Resolution.exec('sysctl vm.swapusage')
 
130
  swapfree, swaptotal = 0, 0
 
131
  unless swap.empty?
 
132
    # Parse the line:
 
133
    # vm.swapusage: total = 128.00M  used = 0.37M  free = 127.63M  (encrypted)
 
134
    if swap =~ /total\s=\s(\S+)\s+used\s=\s(\S+)\s+free\s=\s(\S+)\s/
 
135
      swaptotal += $1.to_i
 
136
      swapfree  += $3.to_i
 
137
    end
 
138
  end
 
139
 
 
140
  Facter.add("SwapSize") do
 
141
    confine :kernel => :Darwin
 
142
    setcode do
 
143
      Facter::Memory.scale_number(swaptotal.to_f,"MB")
 
144
    end
 
145
  end
 
146
 
 
147
  Facter.add("SwapFree") do
 
148
    confine :kernel => :Darwin
 
149
    setcode do
 
150
      Facter::Memory.scale_number(swapfree.to_f,"MB")
 
151
    end
 
152
  end
 
153
 
 
154
  Facter::Memory.vmstat_darwin_find_free_memory()
 
155
 
 
156
  Facter.add("MemoryTotal") do
 
157
    confine :kernel => :Darwin
 
158
    memtotal = Facter::Util::Resolution.exec("sysctl hw.memsize | cut -d':' -f2")
 
159
    setcode do
 
160
      Facter::Memory.scale_number(memtotal.to_f,"")
 
161
    end
 
162
  end
165
163
end
166
164
 
167
165
if Facter.value(:kernel) == "SunOS"
168
 
    swap = Facter::Util::Resolution.exec('/usr/sbin/swap -l')
169
 
    swapfree, swaptotal = 0, 0
170
 
    swap.each_line do |dev|
171
 
        if dev =~ /^\/\S+\s.*\s+(\d+)\s+(\d+)$/
172
 
            swaptotal += $1.to_i / 2
173
 
            swapfree  += $2.to_i / 2
174
 
        end
175
 
    end
176
 
 
177
 
    Facter.add("SwapSize") do
178
 
        confine :kernel => :sunos
179
 
        setcode do
180
 
            Facter::Memory.scale_number(swaptotal.to_f,"kB")
181
 
        end
182
 
    end
183
 
 
184
 
    Facter.add("SwapFree") do
185
 
        confine :kernel => :sunos
186
 
        setcode do
187
 
            Facter::Memory.scale_number(swapfree.to_f,"kB")
188
 
        end
189
 
    end
190
 
 
191
 
    # Total memory size available from prtconf
192
 
    pconf = Facter::Util::Resolution.exec('/usr/sbin/prtconf')
193
 
    phymem = ""
194
 
    pconf.each_line do |line|
195
 
        if line =~ /^Memory size:\s+(\d+) Megabytes/
196
 
            phymem = $1
197
 
        end
198
 
    end
199
 
 
200
 
    Facter.add("MemorySize") do
201
 
        confine :kernel => :sunos
202
 
        setcode do
203
 
            Facter::Memory.scale_number(phymem.to_f,"MB")
204
 
        end
205
 
    end
206
 
 
207
 
    Facter::Memory.vmstat_find_free_memory()
 
166
  swap = Facter::Util::Resolution.exec('/usr/sbin/swap -l')
 
167
  swapfree, swaptotal = 0, 0
 
168
  swap.each_line do |dev|
 
169
    if dev =~ /^\/\S+\s.*\s+(\d+)\s+(\d+)$/
 
170
      swaptotal += $1.to_i / 2
 
171
      swapfree  += $2.to_i / 2
 
172
    end
 
173
  end
 
174
 
 
175
  Facter.add("SwapSize") do
 
176
    confine :kernel => :sunos
 
177
    setcode do
 
178
      Facter::Memory.scale_number(swaptotal.to_f,"kB")
 
179
    end
 
180
  end
 
181
 
 
182
  Facter.add("SwapFree") do
 
183
    confine :kernel => :sunos
 
184
    setcode do
 
185
      Facter::Memory.scale_number(swapfree.to_f,"kB")
 
186
    end
 
187
  end
 
188
 
 
189
  # Total memory size available from prtconf
 
190
  pconf = Facter::Util::Resolution.exec('/usr/sbin/prtconf 2>/dev/null')
 
191
  phymem = ""
 
192
  pconf.each_line do |line|
 
193
    if line =~ /^Memory size:\s+(\d+) Megabytes/
 
194
      phymem = $1
 
195
    end
 
196
  end
 
197
 
 
198
  Facter.add("MemorySize") do
 
199
    confine :kernel => :sunos
 
200
    setcode do
 
201
      Facter::Memory.scale_number(phymem.to_f,"MB")
 
202
    end
 
203
  end
 
204
 
 
205
  Facter::Memory.vmstat_find_free_memory()
208
206
end
209
207
 
210
208
if Facter.value(:kernel) == "windows"
234
232
    end
235
233
  end
236
234
end
 
235
 
 
236
Facter.add("SwapSize") do
 
237
  confine :kernel => :dragonfly
 
238
  setcode do
 
239
    page_size = Facter::Util::Resolution.exec("/sbin/sysctl -n hw.pagesize").to_f
 
240
    swaptotal = Facter::Util::Resolution.exec("/sbin/sysctl -n vm.swap_size").to_f * page_size
 
241
    Facter::Memory.scale_number(swaptotal.to_f,"")
 
242
  end
 
243
end
 
244
 
 
245
Facter.add("SwapFree") do
 
246
  confine :kernel => :dragonfly
 
247
  setcode do
 
248
    page_size = Facter::Util::Resolution.exec("/sbin/sysctl -n hw.pagesize").to_f
 
249
    swaptotal = Facter::Util::Resolution.exec("/sbin/sysctl -n vm.swap_size").to_f * page_size
 
250
    swap_anon_use = Facter::Util::Resolution.exec("/sbin/sysctl -n vm.swap_anon_use").to_f * page_size
 
251
    swap_cache_use = Facter::Util::Resolution.exec("/sbin/sysctl -n vm.swap_cache_use").to_f * page_size
 
252
    swapfree = swaptotal - swap_anon_use - swap_cache_use
 
253
    Facter::Memory.scale_number(swapfree.to_f,"")
 
254
  end
 
255
end
 
256
 
 
257
Facter.add("MemoryTotal") do
 
258
  confine :kernel => :dragonfly
 
259
  setcode do
 
260
    Facter::Memory.vmstat_find_free_memory()
 
261
    memtotal = Facter::Util::Resolution.exec("sysctl -n hw.physmem")
 
262
    Facter::Memory.scale_number(memtotal.to_f,"")
 
263
  end
 
264
end