Class: Minke::Config::Reader

Inherits:
Object
  • Object
show all
Defined in:
lib/minke/config/reader.rb

Overview

Reader reads a yaml based configuration and processes it into a Minke::Config::Config instance

Instance Method Summary collapse

Instance Method Details

#read(config_file) ⇒ Object

read yaml config file and return Minke::Config::Config instance



8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
 
# File 'lib/minke/config/reader.rb', line 8

def read config_file
  b = binding

  config = Config.new
  file   = ERB.new(File.read(config_file)).result b
  file   = YAML.load(file)

  config.namespace        = file['namespace']
  config.application_name = file['application_name']
  config.generator_name   = file['generator_name']

  config.docker_registry = read_docker_registry file['docker_registry'] unless file['docker_registry'] == nil
  config.docker          = read_docker_section file['docker']           unless file['docker'] == nil

  config.fetch    = read_task_section file['fetch'], config.docker    unless file['fetch'] == nil
  config.build    = read_task_section file['build'], config.docker    unless file['build'] == nil
  config.test     = read_task_section file['test'], config.docker     unless file['test'] == nil
  config.run      = read_task_section file['run'], config.docker      unless file['run'] == nil
  config.cucumber = read_task_section file['cucumber'], config.docker unless file['cucumber'] == nil

  return config
end

#read_consul_loader_section(section) ⇒ Object 



76
77
78
79
80
81
 
# File 'lib/minke/config/reader.rb', line 76

def read_consul_loader_section section
  ConsulLoader.new.tap do |c|
    c.config_file = section['config_file']
    c.url         = read_url section['url']
  end
end

#read_copy_section(section) ⇒ Object 



67
68
69
70
71
72
73
74
 
# File 'lib/minke/config/reader.rb', line 67

def read_copy_section section
  section.map do |s|
    Copy.new.tap do |c|
      c.from = s['from']
      c.to   = s['to']
    end
  end
end

#read_docker_registry(section) ⇒ Object 



31
32
33
34
35
36
37
38
39
 
# File 'lib/minke/config/reader.rb', line 31

def read_docker_registry section
  DockerRegistrySettings.new.tap do |d|
    d.url       = section['url'].is_a?(Hash) ? read_secure(section['url']) : section['url']
    d.user      = section['user'].is_a?(Hash) ? read_secure(section['user']) : section['user']
    d.password  = section['password'].is_a?(Hash) ? read_secure(section['password']) : section['password']
    d.email     = section['email'].is_a?(Hash) ? read_secure(section['email']) : section['email']
    d.namespace = section['namespace'].is_a?(Hash) ? read_secure(section['namespace']) : section['namespace']
  end
end

#read_docker_section(section) ⇒ Object 



41
42
43
44
45
46
47
48
 
# File 'lib/minke/config/reader.rb', line 41

def read_docker_section section
  DockerSettings.new.tap do |d|
    d.build_image              = section['build_image']              unless section['build_image'] == nil
    d.build_docker_file        = section['build_docker_file']        unless section['build_docker_file'] == nil
    d.application_docker_file  = section['application_docker_file']  unless section['application_docker_file'] == nil
    d.application_compose_file = section['application_compose_file'] unless section['application_compose_file'] == nil
  end
end

#read_pre_post_section(section) ⇒ Object 



58
59
60
61
62
63
64
65
 
# File 'lib/minke/config/reader.rb', line 58

def read_pre_post_section section
  TaskRunSettings.new.tap do |tr|
    tr.tasks         = section['tasks']                                    unless section['tasks'] == nil
    tr.copy          = read_copy_section section['copy']                   unless section['copy'] == nil
    tr.consul_loader = read_consul_loader_section section['consul_loader'] unless section['consul_loader'] == nil
    tr.health_check  = read_url section['health_check']                    unless section['health_check'] == nil
  end
end

#read_secure(hash) ⇒ Object 



93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
 
# File 'lib/minke/config/reader.rb', line 93

def read_secure hash
  key_path = ENV['SSL_KEY_PATH'].to_s == '' ? "#{ENV['HOME']}/.ssh" : ENV['SSL_KEY_PATH']
  unless Dir.exists? key_path
    puts "Unable to find SSH keys to decrypt secrets, please set environment variable SSL_KEY_PATH or place the keys in ~/.ssh"
    return
  end

  fingerprint = hash['secure']['fingerprint']
  value = hash['secure']['value']

  locator = Minke::Encryption::KeyLocator.new key_path
  key_path = locator.locate_key fingerprint

  puts key_path
  if key_path.to_s.empty?
    puts "Unable to find SSL key matching fingerprint if your SSL keys are not in ~/.ssh you can set the environment variable SSL_KEY_PATH to point to the correct directory."
    return
  end

  encrypt = Minke::Encryption::Encryption.new key_path
  encrypt.decrypt_string value
end

#read_task_section(section, docker_config) ⇒ Object 



50
51
52
53
54
55
56
 
# File 'lib/minke/config/reader.rb', line 50

def read_task_section section, docker_config
  Task.new.tap do |t|
    t.docker = read_docker_section section['docker'] unless section['docker'] == nil
    t.pre    = read_pre_post_section section['pre']  unless section['pre'] == nil
    t.post   = read_pre_post_section section['post'] unless section['post'] == nil
  end
end

#read_url(section) ⇒ Object 



83
84
85
86
87
88
89
90
91
 
# File 'lib/minke/config/reader.rb', line 83

def read_url section
  URL.new.tap do |url|
    url.address  = section['address']
    url.port     = section['port']     != nil ? section['port'].to_s : '80'
    url.path     = section['path']     != nil ? section['path'] : ''
    url.protocol = section['protocol'] != nil ? section['protocol'] : 'http'
    url.type     = section['type']
  end
end