Class: Hcloud::Client

Inherits:
Object
  • Object
show all
Defined in:
lib/hcloud/client.rb

Defined Under Namespace

Classes: ResourceFuture

Constant Summary collapse

MAX_ENTRIES_PER_PAGE = 
50

Class Attribute Summary collapse

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(token:, auto_pagination: false, concurrency: 20, user_agent: nil) ⇒ Client

Returns a new instance of Client.



23
24
25
26
27
28
29
 
# File 'lib/hcloud/client.rb', line 23

def initialize(token:, auto_pagination: false, concurrency: 20, user_agent: nil)
  @token = token
  @user_agent = user_agent || "hcloud-ruby v#{VERSION}"
  @auto_pagination = auto_pagination
  @concurrency = concurrency
  @hydra = Typhoeus::Hydra.new(max_concurrency: concurrency)
end

Class Attribute Details

.connection ⇒ Object

Raises:

  • (ArgumentError) 


15
16
17
18
19
 
# File 'lib/hcloud/client.rb', line 15

def connection
  return @connection if @connection.is_a? Hcloud::Client

  raise ArgumentError, "client not correctly initialized, actually #{@client.inspect}"
end

Instance Attribute Details

#auto_pagination ⇒ Object (readonly)

Returns the value of attribute auto_pagination.



22
23
24
 
# File 'lib/hcloud/client.rb', line 22

def auto_pagination
  @auto_pagination
end

#hydra ⇒ Object (readonly)

Returns the value of attribute hydra.



22
23
24
 
# File 'lib/hcloud/client.rb', line 22

def hydra
  @hydra
end

#token ⇒ Object (readonly)

Returns the value of attribute token.



22
23
24
 
# File 'lib/hcloud/client.rb', line 22

def token
  @token
end

#user_agent ⇒ Object (readonly)

Returns the value of attribute user_agent.



22
23
24
 
# File 'lib/hcloud/client.rb', line 22

def user_agent
  @user_agent
end

Instance Method Details

#actions ⇒ Object 



60
61
62
 
# File 'lib/hcloud/client.rb', line 60

def actions
  ActionResource.new(client: self)
end

#authorized? ⇒ Boolean

Returns:

  • (Boolean) 


49
50
51
52
53
54
 
# File 'lib/hcloud/client.rb', line 49

def authorized?
  request('server_types').run
  true
rescue Error::Unauthorized
  false
end

#concurrent ⇒ Object 



31
32
33
34
35
36
37
38
39
40
41
42
43
 
# File 'lib/hcloud/client.rb', line 31

def concurrent
  @concurrent = true
  ret = yield
  ret.each do |element|
    next unless element.is_a?(AbstractResource)

    element.run
  end
  hydra.run
  ret
ensure
  @concurrent = nil
end

#concurrent? ⇒ Boolean

Returns:

  • (Boolean) 


45
46
47
 
# File 'lib/hcloud/client.rb', line 45

def concurrent?
  !@concurrent.nil?
end

#datacenters ⇒ Object 



72
73
74
 
# File 'lib/hcloud/client.rb', line 72

def datacenters
  DatacenterResource.new(client: self)
end

#floating_ips ⇒ Object 



88
89
90
 
# File 'lib/hcloud/client.rb', line 88

def floating_ips
  FloatingIPResource.new(client: self)
end

#images ⇒ Object 



68
69
70
 
# File 'lib/hcloud/client.rb', line 68

def images
  ImageResource.new(client: self)
end

#isos ⇒ Object 



64
65
66
 
# File 'lib/hcloud/client.rb', line 64

def isos
  IsoResource.new(client: self)
end

#locations ⇒ Object 



76
77
78
 
# File 'lib/hcloud/client.rb', line 76

def locations
  LocationResource.new(client: self)
end

#networks ⇒ Object 



92
93
94
 
# File 'lib/hcloud/client.rb', line 92

def networks
  NetworkResource.new(client: self)
end

#prepare_request(url, **args, &block) ⇒ Object 



110
111
112
113
114
115
116
 
# File 'lib/hcloud/client.rb', line 110

def prepare_request(url, **args, &block)
  req = request(url, **args.merge(block: block))
  return req.run.resource unless concurrent?

  hydra.queue req
  ResourceFuture.new(req)
end

#request(path, **options) ⇒ Object

rubocop:disable Metrics/MethodLength



118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
 
# File 'lib/hcloud/client.rb', line 118

def request(path, **options) # rubocop:disable Metrics/MethodLength
  hcloud_attributes = TyphoeusExt.collect_attributes(options)
  if x = options.delete(:j)
    options[:body] = Oj.dump(x, mode: :compat)
    options[:method] ||= :post
  end
  q = []
  q << options.delete(:ep).to_s
  if x = options.delete(:q)
    q << x.to_param
  end
  path = path.dup
  path << '?' + q.join('&')
  r = Typhoeus::Request.new(
    "https://api.hetzner.cloud/v1/#{path}",
    {
      headers: {
        'Authorization' => "Bearer #{token}",
        'User-Agent' => user_agent,
        'Content-Type' => 'application/json'
      }
    }.merge(options)
  )
  r.on_complete do |response|
    response.extend(TyphoeusExt)
    response.attributes = hcloud_attributes
    response.context.client = self
    response.check_for_error unless response.request.hydra
  end
  r
end

#server_types ⇒ Object 



80
81
82
 
# File 'lib/hcloud/client.rb', line 80

def server_types
  ServerTypeResource.new(client: self)
end

#servers ⇒ Object 



56
57
58
 
# File 'lib/hcloud/client.rb', line 56

def servers
  ServerResource.new(client: self)
end

#ssh_keys ⇒ Object 



84
85
86
 
# File 'lib/hcloud/client.rb', line 84

def ssh_keys
  SSHKeyResource.new(client: self)
end

#volumes ⇒ Object 



96
97
98
 
# File 'lib/hcloud/client.rb', line 96

def volumes
  VolumeResource.new(client: self)
end