Class: VagrantPlugins::HP::Action::CreateServer

Inherits:
Object
  • Object
show all
Includes:
Vagrant::Util::Retryable
Defined in:
lib/vagrant-hp/action/create_server.rb

Overview

This creates server on HP Cloud.

Instance Method Summary collapse

Constructor Details

#initialize(app, env) ⇒ CreateServer

Returns a new instance of CreateServer.



16
17
18
19
 
# File 'lib/vagrant-hp/action/create_server.rb', line 16

def initialize(app, env)
  @app    = app
  @logger = Log4r::Logger.new('vagrant_hp::action::create_server')
end

Instance Method Details

#call(env) ⇒ Object

Raises:

  • (Errors::NoMatchingFlavor) 


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
 
# File 'lib/vagrant-hp/action/create_server.rb', line 21

def call(env)
  # Get the configs
  config = env[:machine].provider_config

  # Find the flavor
  env[:ui].info(I18n.t('vagrant_hp.finding_flavor'))
  flavor = find_match(env[:hp_compute].flavors.all, config.flavor)
  raise Errors::NoMatchingFlavor unless flavor

  # Find the image
  env[:ui].info(I18n.t('vagrant_hp.finding_image'))
  image = find_match(env[:hp_compute].images, config.image)
  raise Errors::NoMatchingImage unless image

  # Find the floating-ip
  if config.floating_ip
      env[:ui].info(I18n.t('vagrant_hp.finding_floating_ip'))
      fip = env[:hp_compute].addresses.find { |fip| fip.ip.eql? config.floating_ip }
      raise Errors::NoMatchingFloatingIp unless fip
  end

  # Figure out the name for the server
  server_name = config.server_name || env[:machine].name if \
                  env[:machine].name != 'default' || get_server_name

  # Output the settings we're going to use to the user
  env[:ui].info(I18n.t('vagrant_hp.launching_server'))
  env[:ui].info(" -- Flavor: #{flavor.name}")
  env[:ui].info(" -- Image: #{image.name}")
  env[:ui].info(" -- Name: #{server_name}")
  env[:ui].info(" -- Key-name: #{config.keypair_name}")
  if config.security_groups
    env[:ui].info(" -- Security Groups: #{config.security_groups}")
  end

  # Build the options for launching...
  options = {
    flavor_id:       flavor.id,
    image_id:        image.id,
    name:            server_name,
    key_name:        config.keypair_name,
    security_groups: config.security_groups
  }

  # Find network if provided in Vagrantfile
  if config.network
      networks = Array.new
      env[:ui].info(I18n.t('vagrant_hp.finding_network'))
      config.network.each do |net|
        network = find_match(env[:hp_network].networks, net)
        networks.push(network.id) if network
      end
      options[:networks] = networks
  end

  # Create the server
  server = env[:hp_compute].servers.create(options)

  # Store the ID right away so we can track it
  env[:machine].id = server.id

  # Wait for the server to finish building
  env[:ui].info(I18n.t('vagrant_hp.waiting_for_build'))
  retryable(on: Timeout::Error, tries: 200) do
    # If we're interrupted don't worry about waiting
    next if env[:interrupted]

    # Set the progress
    env[:ui].clear_line
    env[:ui].report_progress(server.progress, 100, false)

    # Wait for the server to be ready
    begin
      server.wait_for(30) { ready? }

    rescue RuntimeError, Fog::Errors::TimeoutError => e
      # If we don't have an error about a state transition, then
      # we just move on.
      # raise if e.message !~ /should have transitioned/
      env[:ui].info("Error: #{e.message}")
    end
  end
  env[:ui].clear_line
  if not config.floating_ip
    env[:ui].clear_line
    env[:ui].info(I18n.t('vagrant_hp.new_floating_ip_to_server'))
    fip = env[:hp_compute].addresses.create
  end
  fip.server = server

  unless env[:interrupted]
    # Clear the line one more time so the progress is removed
    env[:ui].clear_line

    # Wait for SSH to become available
    env[:ui].info(I18n.t('vagrant_hp.waiting_for_ssh'))
    while true
      begin
        # If we're interrupted then just back out
        break if env[:interrupted]
        break if env[:machine].communicate.ready?
      rescue Errno::ENETUNREACH
      end
      sleep 2
    end

    env[:ui].info(I18n.t('vagrant_hp.ready'))
  end

  @app.call(env)
end