module Miasma::Models::Orchestration::Terraform::Boule

Public Instance Methods

event_all(stack, marker = nil) click to toggle source

Return all events for stack

@param stack [Models::Orchestration::Stack] @return [Array<Models::Orchestration::Stack::Event>]

# File lib/miasma/contrib/terraform/orchestration.rb, line 398
def event_all(stack, marker = nil)
  params = marker ? {:marker => marker} : {}
  result = request(
    :path => "/terraform/events/#{stack.name}",
    :method => :get,
    :params => params
  )
  result.fetch(:body, :events, []).map do |event|
    Stack::Event.new(
      stack,
      :id => event[:id],
      :resource_id => event[:physical_resource_id],
      :resource_name => event[:resource_name],
      :resource_logical_id => event[:resource_name],
      :resource_state => event[:resource_status].downcase.to_sym,
      :resource_status => event[:resource_status],
      :resource_status_reason => event[:resource_status_reason],
      :time => Time.at(event[:timestamp] / 1000.0)
    ).valid_state
  end
end
event_all_new(events) click to toggle source

Return all new events for event collection

@param events [Models::Orchestration::Stack::Events] @return [Array<Models::Orchestration::Stack::Event>]

# File lib/miasma/contrib/terraform/orchestration.rb, line 424
def event_all_new(events)
  event_all(events.stack, events.all.first.id)
end
event_reload(event) click to toggle source

Reload the stack event data from the API

@param resource [Models::Orchestration::Stack::Event] @return [Models::Orchestration::Event]

# File lib/miasma/contrib/terraform/orchestration.rb, line 432
def event_reload(event)
  event.stack.events.reload
  event.stack.events.get(event.id)
end
resource_all(stack) click to toggle source

Return all resources for stack

@param stack [Models::Orchestration::Stack] @return [Array<Models::Orchestration::Stack::Resource>]

# File lib/miasma/contrib/terraform/orchestration.rb, line 365
def resource_all(stack)
  result = request(
    :method => :get,
    :path => "/terraform/resources/#{stack.name}"
  )
  result.fetch(:body, :resources, []).map do |resource|
    Stack::Resource.new(
      stack,
      :id => resource[:physical_id],
      :name => resource[:name],
      :type => resource[:type],
      :logical_id => resource[:name],
      :state => resource[:status].downcase.to_sym,
      :status => resource[:status],
      :status_reason => resource[:resource_status_reason],
      :updated => resource[:updated_time].to_s.empty? ? Time.now : Time.parse(resource[:updated_time])
    ).valid_state
  end
end
resource_reload(resource) click to toggle source

Reload the stack resource data from the API

@param resource [Models::Orchestration::Stack::Resource] @return [Models::Orchestration::Resource]

# File lib/miasma/contrib/terraform/orchestration.rb, line 389
def resource_reload(resource)
  resource.stack.resources.reload
  resource.stack.resources.get(resource.id)
end
stack_all(options={}) click to toggle source

Return all stacks

@param options [Hash] filter @return [Array<Models::Orchestration::Stack>] @todo check if we need any mappings on state set

# File lib/miasma/contrib/terraform/orchestration.rb, line 341
def stack_all(options={})
  result = request(
    :method => :get,
    :path => '/terraform/stacks'
  )
  result.fetch(:body, :stacks, []).map do |s|
    Stack.new(
      self,
      :id => s[:id],
      :created => s[:creation_time].to_s.empty? ? nil : Time.at(s[:creation_time].to_i / 1000.0),
      :description => s[:description],
      :name => s[:name],
      :state => s[:status].downcase.to_sym,
      :status => s[:status],
      :status_reason => s[:stack_status_reason],
      :updated => s[:updated_time].to_s.empty? ? nil : Time.at(s[:updated_time].to_i / 1000.0)
    ).valid_state
  end
end
stack_destroy(stack) click to toggle source

Delete the stack

@param stack [Models::Orchestration::Stack] @return [TrueClass, FalseClass]

# File lib/miasma/contrib/terraform/orchestration.rb, line 289
def stack_destroy(stack)
  if(stack.persisted?)
    request(
      :method => :delete,
      :path => "/terraform/stack/#{stack.name}"
    )
    true
  else
    false
  end
end
stack_reload(stack) click to toggle source

Reload the stack data from the API

@param stack [Models::Orchestration::Stack] @return [Models::Orchestration::Stack]

# File lib/miasma/contrib/terraform/orchestration.rb, line 263
def stack_reload(stack)
  if(stack.persisted?)
    result = request(
      :method => :get,
      :path => "/terraform/stack/#{stack.name}"
    )
    s = result.get(:body, :stack)
    stack.load_data(
      :id => s[:id],
      :created => s[:creation_time].to_s.empty? ? nil : Time.at(s[:creation_time].to_i / 1000.0),
      :description => s[:description],
      :name => s[:name],
      :state => s[:status].downcase.to_sym,
      :status => s[:status],
      :status_reason => s[:stack_status_reason],
      :updated => s[:updated_time].to_s.empty? ? nil : Time.at(s[:updated_time].to_i / 1000.0),
      :outputs => s[:outputs].map{|k,v| {:key => k, :value => v}}
    ).valid_state
  end
  stack
end
stack_save(stack) click to toggle source

Save the stack

@param stack [Models::Orchestration::Stack] @return [Models::Orchestration::Stack]

# File lib/miasma/contrib/terraform/orchestration.rb, line 232
def stack_save(stack)
  if(stack.persisted?)
    stack.load_data(stack.attributes)
    result = request(
      :method => :put,
      :path => "/terraform/stack/#{stack.name}",
      :json => {
        :template => MultiJson.dump(stack.template),
        :parameters => stack.parameters || {}
      }
    )
    stack.valid_state
  else
    stack.load_data(stack.attributes)
    result = request(
      :method => :post,
      :path => "/terraform/stack/#{stack.name}",
      :json => {
        :template => MultiJson.dump(stack.template),
        :parameters => stack.parameters || {}
      }
    )
    stack.id = result.get(:body, :stack, :id)
    stack.valid_state
  end
end
stack_template_load(stack) click to toggle source

Fetch stack template

@param stack [Stack] @return [Smash] stack template

# File lib/miasma/contrib/terraform/orchestration.rb, line 305
def stack_template_load(stack)
  if(stack.persisted?)
    result = request(
      :method => :get,
      :path => "/terraform/template/#{stack.name}"
    )
    result.fetch(:body, Smash.new)
  else
    Smash.new
  end
end
stack_template_validate(stack) click to toggle source

Validate stack template

@param stack [Stack] @return [NilClass, String] nil if valid, string error message if invalid

# File lib/miasma/contrib/terraform/orchestration.rb, line 321
def stack_template_validate(stack)
  begin
    result = request(
      :method => :post,
      :path => '/terraform/validate',
      :json => Smash.new(
        :template => stack.template
      )
    )
    nil
  rescue Error::ApiError::RequestError => e
    MultiJson.load(e.response.body.to_s).to_smash.get(:error, :message)
  end
end