summaryrefslogtreecommitdiff
path: root/bin/puppet_command
blob: eb3cd0b900a27fae5a2430749afabac5d89fb30d (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
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
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
#!/usr/bin/ruby

#
# This is a wrapper script around the puppet command used by the LEAP platform.
#
# We do this in order to make it faster and easier to control puppet remotely
# (exit codes, logging, lockfile, version check, etc)
#

require 'pty'
require 'yaml'
require 'logger'
require 'socket'
require 'fileutils'

DEBIAN_VERSION    = /^(jessie|8\.)/
PUPPET_BIN        = '/usr/bin/puppet'
PUPPET_DIRECTORY  = '/srv/leap'
PUPPET_PARAMETERS = '--color=false --detailed-exitcodes --libdir=puppet/lib --confdir=puppet'
SITE_MANIFEST     = 'puppet/manifests/site.pp'
SITE_MODULES      = 'puppet/modules'
CUSTOM_MODULES    = ':files/puppet/modules'
DEFAULT_TAGS      = 'leap_base,leap_service'
HIERA_FILE        = '/etc/leap/hiera.yaml'
LOG_DIR           = '/var/log/leap'
DEPLOY_LOG        = '/var/log/leap/deploy.log'
SUMMARY_LOG       = '/var/log/leap/deploy-summary.log'
SUMMARY_LOG_1     = '/var/log/leap/deploy-summary.log.1'
APPLY_START_STR   = "STARTING APPLY"
APPLY_FINISH_STR  = "APPLY COMPLETE"


def main
  if File.read('/etc/debian_version') !~ DEBIAN_VERSION
    log "ERROR: This operating system is not supported. The file /etc/debian_version must match #{DEBIAN_VERSION}."
    exit 1
  end
  process_command_line_arguments
  with_lockfile do
    @commands.each do |command|
      self.send(command)
    end
  end
end

def open_log_files
  FileUtils.mkdir_p(LOG_DIR)
  $logger = Logger.new(DEPLOY_LOG)
  $summary_logger = Logger.new(SUMMARY_LOG)
  [$logger, $summary_logger].each do |logger|
    logger.level = Logger::INFO
    logger.formatter = proc do |severity, datetime, progname, msg|
      "%s %s: %s\n" % [datetime.strftime("%b %d %H:%M:%S"), Socket.gethostname, msg]
    end
  end
end

def close_log_files
  $logger.close
  $summary_logger.close
end

def log(str, *args)
  str = str.strip
  $stdout.puts str
  $stdout.flush
  if $logger
    $logger.info(str)
    if args.include? :summary
      $summary_logger.info(str)
    end
  end
end

def process_command_line_arguments
  @commands = []
  @verbosity = 1
  @tags = DEFAULT_TAGS
  @info = {}
  @downgrade = false
  loop do
    case ARGV[0]
      when 'apply'        then ARGV.shift; @commands << 'apply'
      when 'set_hostname' then ARGV.shift; @commands << 'set_hostname'
      when '--verbosity'  then ARGV.shift; @verbosity = ARGV.shift.to_i
      when '--force'      then ARGV.shift; remove_lockfile
      when '--tags'       then ARGV.shift; @tags      = ARGV.shift
      when '--info'       then ARGV.shift; @info      = parse_info(ARGV.shift)
      when '--downgrade'  then ARGV.shift; @downgrade = true
      when /^-/           then usage("Unknown option: #{ARGV[0].inspect}")
      else break
    end
  end
  usage("No command given") unless @commands.any?
end

def apply
  platform_version_check! unless @downgrade
  log "#{APPLY_START_STR} {#{format_info(@info)}}", :summary
  exit_code = puppet_apply do |line|
    log line
  end
  log "#{APPLY_FINISH_STR} (#{exitcode_description(exit_code)}) {#{format_info(@info)}}", :summary
end

def set_hostname
  hostname = hiera_file['name']
  if hostname.nil? || hostname.empty?
    log('ERROR: "name" missing from hiera file')
    exit(1)
  end
  current_hostname_file = File.read('/etc/hostname') rescue nil
  current_hostname = `/bin/hostname`.strip

  # set /etc/hostname
  if current_hostname_file != hostname
    File.open('/etc/hostname', 'w', 0611, :encoding => 'ascii') do |f|
      f.write hostname
    end
    if File.read('/etc/hostname') == hostname
      log "Changed /etc/hostname to #{hostname}"
    else
      log "ERROR: failed to update /etc/hostname"
    end
  end

  # call /bin/hostname
  if current_hostname != hostname
    if run("/bin/hostname #{hostname}") == 0
      log "Changed hostname to #{hostname}"
    else
      log "ERROR: call to `/bin/hostname #{hostname}` returned an error."
    end
  end
end

#
# each line of output is yielded. the exit code is returned.
#
def puppet_apply(options={}, &block)
  options = {:verbosity => @verbosity, :tags => @tags}.merge(options)
  manifest = options[:manifest] || SITE_MANIFEST
  modulepath = options[:module_path] || SITE_MODULES + CUSTOM_MODULES
  fqdn = hiera_file['domain']['full']
  domain = hiera_file['domain']['full_suffix']
  Dir.chdir(PUPPET_DIRECTORY) do
    return run("FACTER_fqdn='#{fqdn}' FACTER_domain='#{domain}' #{PUPPET_BIN} apply #{custom_parameters(options)} --modulepath='#{modulepath}' #{PUPPET_PARAMETERS} #{manifest}", &block)
  end
end

#
# parse the --info flag. example str: "key1: value1, key2: value2, ..."
#
def parse_info(str)
  str.split(', ').
    map {|i| i.split(': ')}.
    inject({}) {|h,i| h[i[0]] = i[1]; h}
rescue Exception => exc
  {"platform" => "INVALID_FORMAT"}
end

def format_info(info)
  info.to_a.map{|i|i.join(': ')}.join(', ')
end

#
# exits with a warning message if the last successful deployed
# platform was newer than the one we are currently attempting to
# deploy.
#
PLATFORM_RE = /\{.*platform: ([0-9\.]+)[ ,\}].*[\}$]/
def platform_version_check!
  return unless @info["platform"]
  new_version = @info["platform"].split(' ').first
  return unless new_version
  if File.exists?(SUMMARY_LOG) && File.size(SUMMARY_LOG) != 0
    file = SUMMARY_LOG
  elsif File.exists?(SUMMARY_LOG_1) && File.size(SUMMARY_LOG_1) != 0
    file = SUMMARY_LOG_1
  else
    return
  end
  most_recent_line = `tail '#{file}'`.split("\n").grep(PLATFORM_RE).last
  if most_recent_line
    prior_version = most_recent_line.match(PLATFORM_RE)[1]
    if Gem::Version.new(prior_version) > Gem::Version.new(new_version)
      log("ERROR: You are attempting to deploy platform v#{new_version} but this node uses v#{prior_version}.")
      log("       Run with --downgrade if you really want to deploy an older platform version.")
      exit(0)
    end
  end
end

#
# Return a ruby object representing the contents of the hiera yaml file.
#
def hiera_file
  unless File.exists?(HIERA_FILE)
    log("ERROR: hiera file '#{HIERA_FILE}' does not exist.")
    exit(1)
  end
  $hiera_contents ||= YAML.load_file(HIERA_FILE)
  return $hiera_contents
rescue Exception => exc
  log("ERROR: problem reading hiera file '#{HIERA_FILE}' (#{exc})")
  exit(1)
end

def custom_parameters(options)
  params = []
  if options[:tags] && options[:tags].chars.any?
    params << "--tags #{options[:tags]}"
  end
  if options[:verbosity]
    case options[:verbosity]
      when 3 then params << '--verbose'
      when 4 then params << '--verbose --debug'
      when 5 then params << '--verbose --debug --trace'
    end
  end
  params.join(' ')
end

def exitcode_description(code)
  case code
    when 0 then "no changes"
    when 1 then "failed"
    when 2 then "changes made"
    when 4 then "failed"
    when 6 then "changes and failures"
    else code
  end
end

def usage(s)
  $stderr.puts(s)
  $stderr.puts
  $stderr.puts("Usage: #{File.basename($0)} COMMAND [OPTIONS]")
  $stderr.puts
  $stderr.puts("COMMAND may be one or more of:
  set_hostname     -- set the hostname of this server.
  apply            -- apply puppet manifests.")
  $stderr.puts
  $stderr.puts("OPTIONS may be one or more of:
  --verbosity VERB -- set the verbosity level 0..5.
  --tags TAGS      -- set the tags to pass through to puppet.
  --force          -- run even when lockfile is present.
  --info           -- additional info to include in logs (e.g. 'user: alice, platform: 0.6.1')
  --downgrade      -- allow a deploy even if the platform version is older than previous deploy.
  ")
  exit(2)
end

##
## Simple lock file
##

require 'fileutils'
DEFAULT_LOCKFILE = '/tmp/puppet.lock'

def remove_lockfile(lock_file_path=DEFAULT_LOCKFILE)
  FileUtils.remove_file(lock_file_path, true)
end

def with_lockfile(lock_file_path=DEFAULT_LOCKFILE)
  begin
    File.open(lock_file_path, File::CREAT | File::EXCL | File::WRONLY) do |o|
      o.write(Process.pid)
    end
    open_log_files
    yield
    remove_lockfile
    close_log_files
  rescue Errno::EEXIST
    log("ERROR: the lock file '#{lock_file_path}' already exists. Wait a minute for the process to die, or run with --force to ignore. Bailing out.")
    exit(1)
  rescue IOError => exc
    log("ERROR: problem with lock file '#{lock_file_path}' (#{exc}). Bailing out.")
    exit(1)
  end
end

##
## simple pass through process runner (to ensure output is not buffered and return exit code)
## this only works under ruby 1.9
##

def run(cmd)
  log(cmd) if @verbosity >= 3
  PTY.spawn("#{cmd}") do |output, input, pid|
    begin
      while line = output.gets do
        yield line
      end
    rescue Errno::EIO
    end
    Process.wait(pid) # only works in ruby 1.9, required to capture the exit status.
  end
  return $?.exitstatus
rescue PTY::ChildExited
end

##
## RUN MAIN
##

Signal.trap("EXIT") do
  remove_lockfile # clean up the lockfile when process is terminated.
                  # this will remove the lockfile if ^C killed the process
                  # but only after the child puppet process is also dead (I think).
end

main()