Class: Fog::Proxmox::Compute::Server

Inherits:
Compute::Server
  • Object
show all
Defined in:
lib/fog/proxmox/compute/models/server.rb

Overview

Server model rubocop:disable ClassLength

Instance Method Summary collapse

Constructor Details

#initialize(new_attributes = {}) ⇒ Server

Returns a new instance of Server.



64
65
66
67
68
69
70
71
72
73
74
 
# File 'lib/fog/proxmox/compute/models/server.rb', line 64

def initialize(new_attributes = {})
  prepare_service_value(new_attributes)
  Fog::Proxmox::Attributes.set_attr_and_sym('node_id', attributes, new_attributes)
  Fog::Proxmox::Attributes.set_attr_and_sym('type', attributes, new_attributes)
  Fog::Proxmox::Attributes.set_attr_and_sym('vmid', attributes, new_attributes)
  requires :node_id, :type, :vmid
  initialize_config(new_attributes)
  initialize_snapshots
  initialize_tasks
  super(new_attributes)
end

Instance Method Details

#action(action, options = {}) ⇒ Object

Raises:

  • (Fog::Errors::Error) 


123
124
125
126
127
128
129
130
 
# File 'lib/fog/proxmox/compute/models/server.rb', line 123

def action(action, options = {})
  action_known = %w[start stop resume suspend shutdown reset].include? action
  message = "Action #{action} not implemented"
  raise Fog::Errors::Error, message unless action_known

  request(:action_server, options, action: action, vmid: vmid)
  reload
end

#attach(disk, options = {}) ⇒ Object 



182
183
184
185
 
# File 'lib/fog/proxmox/compute/models/server.rb', line 182

def attach(disk, options = {})
  disk_hash = Fog::Proxmox::DiskHelper.flatten(disk.merge(options: options))
  update(disk_hash)
end

#backup(options = {}) ⇒ Object 



136
137
138
139
 
# File 'lib/fog/proxmox/compute/models/server.rb', line 136

def backup(options = {})
  request(:create_backup, options.merge(vmid: vmid))
  reload
end

#backups ⇒ Object 



229
230
231
 
# File 'lib/fog/proxmox/compute/models/server.rb', line 229

def backups
  list 'backup'
end

#clone(newid, options = {}) ⇒ Object 



150
151
152
153
 
# File 'lib/fog/proxmox/compute/models/server.rb', line 150

def clone(newid, options = {})
  request(:clone_server, options.merge(newid: newid), vmid: vmid)
  reload
end

#connect_vnc(options = {}) ⇒ Object 



223
224
225
226
227
 
# File 'lib/fog/proxmox/compute/models/server.rb', line 223

def connect_vnc(options = {})
  path_params = { node: node_id, type: type, vmid: vmid }
  query_params = { port: options['port'], vncticket: options['ticket'] }
  service.get_vnc(path_params, query_params)
end

#container? ⇒ Boolean

Returns:

  • (Boolean) 


80
81
82
 
# File 'lib/fog/proxmox/compute/models/server.rb', line 80

def container?
  type == 'lxc'
end

#create_template(options = {}) ⇒ Object 



155
156
157
158
 
# File 'lib/fog/proxmox/compute/models/server.rb', line 155

def create_template(options = {})
  service.template_server({ node: node_id, type: type, vmid: vmid }, options)
  reload
end

#destroy(options = {}) ⇒ Object 



119
120
121
 
# File 'lib/fog/proxmox/compute/models/server.rb', line 119

def destroy(options = {})
  request(:delete_server, options, vmid: vmid)
end

#detach(diskid) ⇒ Object 



187
188
189
 
# File 'lib/fog/proxmox/compute/models/server.rb', line 187

def detach(diskid)
  update(delete: diskid)
end

#extend(disk, size, options = {}) ⇒ Object 



164
165
166
167
168
169
170
171
 
# File 'lib/fog/proxmox/compute/models/server.rb', line 164

def extend(disk, size, options = {})
  if container?
    request(:resize_container, options.merge(disk: disk, size: size), vmid: vmid)
  else
    service.resize_server({ vmid: vmid, node: node_id }, options.merge(disk: disk, size: size))
  end
  reload
end

#images ⇒ Object 



233
234
235
 
# File 'lib/fog/proxmox/compute/models/server.rb', line 233

def images
  list 'images'
end

#list(content) ⇒ Object 



237
238
239
240
241
242
 
# File 'lib/fog/proxmox/compute/models/server.rb', line 237

def list(content)
  storages = node.storages.list_by_content_type content
  volumes = []
  storages.each { |storage| volumes += storage.volumes.list_by_content_type_and_by_server(content, identity) }
  volumes
end

#migrate(target, options = {}) ⇒ Object 



160
161
162
 
# File 'lib/fog/proxmox/compute/models/server.rb', line 160

def migrate(target, options = {})
  request(:migrate_server, options.merge(target: target), vmid: vmid)
end

#move(volume, storage, options = {}) ⇒ Object 



173
174
175
176
177
178
179
180
 
# File 'lib/fog/proxmox/compute/models/server.rb', line 173

def move(volume, storage, options = {})
  if container?
    request(:move_volume, options.merge(volume: volume, storage: storage), vmid: vmid)
  else
    request(:move_disk, options.merge(disk: volume, storage: storage), vmid: vmid)
  end
  reload
end

#persisted? ⇒ Boolean

Returns:

  • (Boolean) 


84
85
86
87
88
89
90
91
 
# File 'lib/fog/proxmox/compute/models/server.rb', line 84

def persisted?
  service.next_vmid(vmid: vmid)
  false
rescue Excon::Error::InternalServerError
  false
rescue Excon::Error::BadRequest
  true
end

#ready? ⇒ Boolean

Returns:

  • (Boolean) 


132
133
134
 
# File 'lib/fog/proxmox/compute/models/server.rb', line 132

def ready?
  status == 'running'
end

#request(name, body_params = {}, path_params = {}) ⇒ Object

request with async task



94
95
96
97
98
99
 
# File 'lib/fog/proxmox/compute/models/server.rb', line 94

def request(name, body_params = {}, path_params = {})
  requires :node_id, :type
  path = path_params.merge(node: node_id, type: type)
  task_upid = service.send(name, path, body_params)
  tasks.wait_for(task_upid)
end

#restore(backup, options = {}) ⇒ Object 



141
142
143
144
145
146
147
148
 
# File 'lib/fog/proxmox/compute/models/server.rb', line 141

def restore(backup, options = {})
  attr_hash = if container?
                options.merge(ostemplate: backup.volid, force: 1, restore: 1)
              else
                options.merge(archive: backup.volid, force: 1)
              end
  save(attr_hash)
end

#save(new_attributes = {}) ⇒ Object 



101
102
103
104
105
106
 
# File 'lib/fog/proxmox/compute/models/server.rb', line 101

def save(new_attributes = {})
  body_params = new_attributes.merge(vmid: vmid)
  body_params = body_params.merge(config.flatten) unless persisted?
  request(:create_server, body_params)
  reload
end

#start_console(options = {}) ⇒ Object 



191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
 
# File 'lib/fog/proxmox/compute/models/server.rb', line 191

def start_console(options = {})
  unless ready?
    raise ::Fog::Proxmox::Errors::ServiceError,
          'Unable to start console because server not running.'
  end

  if container?
    type_console = options[:console]
    options.delete_if { |option| [:console].include? option }
    unless type_console
      raise ::Fog::Proxmox::Errors::ServiceError,
            'Unable to start console because console container config is not set or unknown.'
    end
  else
    type_console = config.type_console
    unless type_console
      raise ::Fog::Proxmox::Errors::ServiceError,
            'Unable to start console because VGA display server config is not set or unknown.'
    end
  end
  requires :vmid, :node_id, :type
  path_params = { node: node_id, type: type, vmid: vmid }
  body_params = options
  data = service.send(('create_' + type_console).to_sym, path_params, body_params)
  task_upid = data['upid']
  if task_upid
    task = tasks.get(task_upid)
    task.wait_for { running? }
  end
  data
end

#to_s ⇒ Object 



76
77
78
 
# File 'lib/fog/proxmox/compute/models/server.rb', line 76

def to_s
  name
end

#update(new_attributes = {}) ⇒ Object 



108
109
110
111
112
113
114
115
116
117
 
# File 'lib/fog/proxmox/compute/models/server.rb', line 108

def update(new_attributes = {})
  if container?
    path_params = { node: node_id, type: type, vmid: vmid }
    body_params = new_attributes
    service.update_server(path_params, body_params)
  else
    request(:update_server, new_attributes, vmid: vmid)
  end
  reload
end