Module: Blender::SchedulerDSL

Includes:
Discovery, Utils::Refinements
Included in:
Scheduler
Defined in:
lib/blender/scheduler/dsl.rb

Instance Method Summary collapse

Methods included from Discovery

#build_discovery, #old_search, #search, #search_with_config

Methods included from Utils::Refinements

#camelcase, #symbolize

Instance Method Details

#add_handler(handler) ⇒ Object Also known as: register_handler 



69
70
71
 
# File 'lib/blender/scheduler/dsl.rb', line 69

def add_handler(handler)
  events.register(handler)
end

#append_task(type, task, driver_config = {}) ⇒ Object 



92
93
94
95
96
97
98
99
100
101
102
 
# File 'lib/blender/scheduler/dsl.rb', line 92

def append_task(type, task, driver_config = {})
  Log.debug("Appended task:#{task.name}")
  klass = Blender::Driver.const_get(camelcase(type.to_s).to_sym)
  if task.driver.nil?
    opts = driver_config.dup
    opts.merge!(blender_config(type)) unless blender_config(type).empty?
    opts.merge!(task.driver_opts)
    task.use_driver(driver(type, opts))
  end
  @tasks << task
end

#ask(msg, echo = false) ⇒ Object 



54
55
56
 
# File 'lib/blender/scheduler/dsl.rb', line 54

def ask(msg, echo = false)
  HighLine.new.ask(msg){|q| q.echo = echo}
end

#blend_task(name, &block) ⇒ Object 



141
142
143
144
145
146
147
148
 
# File 'lib/blender/scheduler/dsl.rb', line 141

def blend_task(name, &block)
  task = build_task(name, :blend)
  task.instance_eval(&block) if block_given?
  task.command.pass_configs.each do |key|
    task.command.config_store[key] = blender_config(key).dup
  end
  append_task(:blend, task)
end

#build_task(name, type) ⇒ Object 



85
86
87
88
89
90
 
# File 'lib/blender/scheduler/dsl.rb', line 85

def build_task(name, type)
  task_klass = Blender::Task.const_get(camelcase(type.to_s).to_sym)
  task = task_klass.new(name)
  task.members(metadata[:members]) unless metadata[:members].empty?
  task
end

#concurrency(value) ⇒ Object 



160
161
162
 
# File 'lib/blender/scheduler/dsl.rb', line 160

def concurrency(value)
  @metadata[:concurrency] = value
end

#config(type, opts = {}) ⇒ Object Also known as: init 



44
45
46
 
# File 'lib/blender/scheduler/dsl.rb', line 44

def config(type, opts = {})
  update_config(type, opts)
end

#driver(type, opts = {}) {|config| ... } ⇒ Object

Yields:



58
59
60
61
62
63
64
65
66
67
 
# File 'lib/blender/scheduler/dsl.rb', line 58

def driver(type, opts = {})
  klass_name = camelcase(type.to_s).to_sym
  config = symbolize(opts.merge(events: events))
  yield config if block_given?
  begin
    Blender::Driver.const_get(klass_name).new(config)
  rescue NameError => e
    raise UnknownDriver, e.message
  end
end

#ignore_failure(value) ⇒ Object 



164
165
166
 
# File 'lib/blender/scheduler/dsl.rb', line 164

def ignore_failure(value)
  @metadata[:ignore_failure] = value
end

#lock(opts = {}) ⇒ Object 



177
178
179
180
181
182
183
184
185
186
187
 
# File 'lib/blender/scheduler/dsl.rb', line 177

def lock(opts = {})
  options = lock_properties.dup.merge(opts)
  if options[:driver]
    lock_klass = Lock.const_get(camelcase(options[:driver]).to_sym)
    lock_klass.new(name, options[:driver_options]).with_lock do
      yield if block_given?
    end
  else
    yield if block_given?
  end
end

#lock_options(driver, opts = {}) ⇒ Object 



172
173
174
175
 
# File 'lib/blender/scheduler/dsl.rb', line 172

def lock_options(driver, opts = {})
  @lock_properties[:driver] = driver
  @lock_properties[:driver_options].merge!(opts.dup)
end

#log_level(level) ⇒ Object 



50
51
52
 
# File 'lib/blender/scheduler/dsl.rb', line 50

def log_level(level)
  Blender::Log.level = level
end

#members(hosts) ⇒ Object 



168
169
170
 
# File 'lib/blender/scheduler/dsl.rb', line 168

def members(hosts)
  @metadata[:members] = Array(hosts)
end

#on(event_type, &block) ⇒ Object 



75
76
77
78
79
80
81
82
83
 
# File 'lib/blender/scheduler/dsl.rb', line 75

def on(event_type, &block)
  add_handler(
    Class.new(Handlers::Base) do
      define_method(event_type) do |*args|
        block.call(args)
      end
    end.new
  )
end

#ruby_task(name, &block) ⇒ Object 



111
112
113
114
115
 
# File 'lib/blender/scheduler/dsl.rb', line 111

def ruby_task(name, &block)
  task = build_task(name, :ruby)
  task.instance_eval(&block) if block_given?
  append_task(:ruby, task)
end

#scp_download(name, &block) ⇒ Object 



134
135
136
137
138
139
 
# File 'lib/blender/scheduler/dsl.rb', line 134

def scp_download(name, &block)
  task = build_task(name, :scp)
  task.instance_eval(&block) if block_given?
  task.direction = :download
  append_task(:scp, task, blender_config(:ssh))
end

#scp_upload(name, &block) ⇒ Object 



127
128
129
130
131
132
 
# File 'lib/blender/scheduler/dsl.rb', line 127

def scp_upload(name, &block)
  task = build_task(name, :scp)
  task.instance_eval(&block) if block_given?
  task.direction = :upload
  append_task(:scp, task, blender_config(:ssh))
end

#shell_task(name, &block) ⇒ Object Also known as: task 



104
105
106
107
108
109
 
# File 'lib/blender/scheduler/dsl.rb', line 104

def shell_task(name, &block)
  task = build_task(name, :shell_out)
  task.members(['localhost'])
  task.instance_eval(&block) if block_given?
  append_task(:shell_out, task)
end

#ssh_task(name, &block) ⇒ Object 



117
118
119
120
121
122
123
124
125
 
# File 'lib/blender/scheduler/dsl.rb', line 117

def ssh_task(name, &block)
  task = build_task(name, :ssh)
  task.instance_eval(&block) if block_given?
  if task.metadata[:concurrency] == 1
    append_task(:ssh, task)
  else
    append_task(:ssh_multi, task, blender_config(:ssh))
  end
end

#strategy(strategy) ⇒ Object 



150
151
152
153
154
155
156
157
158
 
# File 'lib/blender/scheduler/dsl.rb', line 150

def strategy(strategy)
  klass_name = camelcase(strategy.to_s).to_sym
  begin
    @scheduling_strategy = Blender::SchedulingStrategy.const_get(klass_name).new
    @scheduling_strategy.freeze
  rescue NameError => e
    raise UnknownSchedulingStrategy, e.message
  end
end