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 



67
68
69
 
# File 'lib/blender/scheduler/dsl.rb', line 67

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

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



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

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 



52
53
54
 
# File 'lib/blender/scheduler/dsl.rb', line 52

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

#build_task(name, type) ⇒ Object 



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

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 



149
150
151
 
# File 'lib/blender/scheduler/dsl.rb', line 149

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

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



42
43
44
 
# File 'lib/blender/scheduler/dsl.rb', line 42

def config(type, opts = {})
  blender_config(type).merge!(opts)
end

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

Yields:



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

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 



153
154
155
 
# File 'lib/blender/scheduler/dsl.rb', line 153

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

#lock(opts = {}) ⇒ Object 



166
167
168
169
170
171
172
173
174
175
176
 
# File 'lib/blender/scheduler/dsl.rb', line 166

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 



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

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

#log_level(level) ⇒ Object 



48
49
50
 
# File 'lib/blender/scheduler/dsl.rb', line 48

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

#members(hosts) ⇒ Object 



157
158
159
 
# File 'lib/blender/scheduler/dsl.rb', line 157

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

#on(event_type, &block) ⇒ Object 



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

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 



109
110
111
112
113
 
# File 'lib/blender/scheduler/dsl.rb', line 109

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 



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

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 



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

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 



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

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 



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

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 



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

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