Class: Puppet::HTTP::Service::Compiler

Inherits:
Puppet::HTTP::Service show all
Defined in:
lib/puppet/http/service/compiler.rb

Overview

The Compiler service is used to submit and retrieve data from the puppetserver.

Constant Summary collapse

API =

Returns Default API for the Compiler service.

Returns:

  • (String) —

    Default API for the Compiler service

'/puppet/v3'.freeze

Constants inherited from Puppet::HTTP::Service

EXCLUDED_FORMATS, SERVICE_NAMES

Instance Attribute Summary

Attributes inherited from Puppet::HTTP::Service

#url

Instance Method Summary collapse

Methods inherited from Puppet::HTTP::Service

#connect, create_service, valid_name?, #with_base_url

Constructor Details

#initialize(client, session, server, port) ⇒ Compiler

Use ‘Puppet::HTTP::Session.route_to(:puppet)` to create or get an instance of this class.

Parameters:

  • client (Puppet::HTTP::Client)
  • session (Puppet::HTTP::Session)
  • server (String) —

    (Puppet[:server]) If an explicit server is given, create a service using that server. If server is nil, the default value is used to create the service.

  • port (Integer) —

    (Puppet[:masterport]) If an explicit port is given, create a service using that port. If port is nil, the default value is used to create the service.



20
21
22
23
 
# File 'lib/puppet/http/service/compiler.rb', line 20

def initialize(client, session, server, port)
  url = build_url(API, server || Puppet[:server], port || Puppet[:serverport])
  super(client, session, url)
end

Instance Method Details

#get_facts(name, environment:) ⇒ Array<Puppet::HTTP::Response, Puppet::Node::Facts>

Submit a GET request to retrieve the facts for the named node.

Parameters:

  • name (String) —

    Name of the node to retrieve facts for

  • environment (String) —

    Name of the environment we are operating in

Returns:



132
133
134
135
136
137
138
139
140
141
142
143
144
 
# File 'lib/puppet/http/service/compiler.rb', line 132

def get_facts(name, environment:)
  headers = add_puppet_headers('Accept' => get_mime_types(Puppet::Node::Facts).join(', '))

  response = @client.get(
    with_base_url("/facts/#{name}"),
    headers: headers,
    params: { environment: environment }
  )

  process_response(response)

  [response, deserialize(response, Puppet::Node::Facts)]
end

#get_filebucket_file(path, environment:, bucket_path: nil, diff_with: nil, list_all: nil, fromdate: nil, todate: nil) ⇒ Array<Puppet::HTTP::Response, Puppet::FileBucket::File>

Submit a GET request to retrieve a file stored with filebucket.

Parameters:

  • path (String) —

    The request path, formatted by Puppet::FileBucket::Dipper

  • environment (String) —

    Name of the environment we are operating in. This should not impact filebucket at all, but is included to be consistent with legacy code.

  • bucket_path (String) (defaults to: nil)
  • diff_with (String) (defaults to: nil) —

    a checksum to diff against if we are comparing files that are both stored in the bucket

  • list_all (String) (defaults to: nil)
  • fromdate (String) (defaults to: nil)
  • todate (String) (defaults to: nil)

Returns:



193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
 
# File 'lib/puppet/http/service/compiler.rb', line 193

def get_filebucket_file(path, environment:, bucket_path: nil, diff_with: nil, list_all: nil, fromdate: nil, todate: nil)
  headers = add_puppet_headers('Accept' => 'application/octet-stream')

  response = @client.get(
    with_base_url("/file_bucket_file/#{path}"),
    headers: headers,
    params: {
      environment: environment,
      bucket_path: bucket_path,
      diff_with: diff_with,
      list_all: list_all,
      fromdate: fromdate,
      todate: todate
    }
  )

  process_response(response)

  [response, deserialize(response, Puppet::FileBucket::File)]
end

#get_node(name, environment:, configured_environment: nil, transaction_uuid: nil) ⇒ Array<Puppet::HTTP::Response, Puppet::Node>

Submit a GET request to retrieve a node from the server.

Parameters:

  • name (String) —

    The name of the node being requested

  • environment (String) —

    The name of the environment we are operating in

  • configured_environment (String) (defaults to: nil) —

    Optional, the name of the configured environment. If unset, environment is used.

  • transaction_uuid (String) (defaults to: nil) —

    An agent generated transaction uuid, used for connecting catalogs and reports.

Returns:



38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
 
# File 'lib/puppet/http/service/compiler.rb', line 38

def get_node(name, environment:, configured_environment: nil, transaction_uuid: nil)
  headers = add_puppet_headers('Accept' => get_mime_types(Puppet::Node).join(', '))

  response = @client.get(
    with_base_url("/node/#{name}"),
    headers: headers,
    params: {
      environment: environment,
      configured_environment: configured_environment || environment,
      transaction_uuid: transaction_uuid,
    }
  )

  process_response(response)

  [response, deserialize(response, Puppet::Node)]
end

#head_filebucket_file(path, environment:, bucket_path: nil) ⇒ Puppet::HTTP::Response

Submit a HEAD request to check the status of a file stored with filebucket.

Parameters:

  • path (String) —

    The request path, formatted by Puppet::FileBucket::Dipper

  • environment (String) —

    Name of the environment we are operating in. This should not impact filebucket at all, but is included to be consistent with legacy code.

  • bucket_path (String) (defaults to: nil)

Returns:



256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
 
# File 'lib/puppet/http/service/compiler.rb', line 256

def head_filebucket_file(path, environment:, bucket_path: nil)
  headers = add_puppet_headers('Accept' => 'application/octet-stream')

  response = @client.head(
    with_base_url("/file_bucket_file/#{path}"),
    headers: headers,
    params: {
      environment: environment,
      bucket_path: bucket_path
    }
  )

  process_response(response)

  response
end

#post_catalog(name, facts:, environment:, configured_environment: nil, transaction_uuid: nil, job_uuid: nil, static_catalog: true, checksum_type: ) ⇒ Array<Puppet::HTTP::Response, Puppet::Resource::Catalog>

Submit a POST request to submit a catalog to the server.

Parameters:

  • name (String) —

    The name of the catalog to be submitted

  • facts (Puppet::Node::Facts) —

    Facts for this catalog

  • environment (String) —

    The name of the environment we are operating in

  • configured_environment (String) (defaults to: nil) —

    Optional, the name of the configured environment. If unset, environment is used.

  • transaction_uuid (String) (defaults to: nil) —

    An agent generated transaction uuid, used for connecting catalogs and reports.

  • job_uuid (String) (defaults to: nil) —

    A unique job identifier defined when the orchestrator starts a puppet run via pxp-agent. This is used to correlate catalogs and reports with the orchestrator job.

  • static_catalog (Boolean) (defaults to: true) —

    Indicates if the file metadata(s) are inlined in the catalog. This informs the agent if it needs to make a second request to retrieve metadata in addition to the initial catalog request.

  • checksum_type (Array<String>) (defaults to: ) —

    An array of accepted checksum types.

Returns:



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
 
# File 'lib/puppet/http/service/compiler.rb', line 78

def post_catalog(name, facts:, environment:, configured_environment: nil, transaction_uuid: nil, job_uuid: nil, static_catalog: true, checksum_type: Puppet[:supported_checksum_types])
  if Puppet[:preferred_serialization_format] == "pson"
    formatter = Puppet::Network::FormatHandler.format_for(:pson)
    # must use 'pson' instead of 'text/pson'
    facts_format = 'pson'
  else
    formatter = Puppet::Network::FormatHandler.format_for(:json)
    facts_format = formatter.mime
  end

  facts_as_string = serialize(formatter, facts)

  # query parameters are sent in the POST request body
  body = {
    facts_format: facts_format,
    facts: Puppet::Util.uri_query_encode(facts_as_string),
    environment: environment,
    configured_environment: configured_environment || environment,
    transaction_uuid: transaction_uuid,
    job_uuid: job_uuid,
    static_catalog: static_catalog,
    checksum_type: checksum_type.join('.')
  }.map do |key, value|
    "#{key}=#{Puppet::Util.uri_query_encode(value.to_s)}"
  end.join("&")

  headers = add_puppet_headers(
    'Accept' => get_mime_types(Puppet::Resource::Catalog).join(', '),
    'Content-Type' => 'application/x-www-form-urlencoded'
  )

  response = @client.post(
    with_base_url("/catalog/#{name}"),
    body,
    headers: headers,
    # for legacy reasons we always send environment as a query parameter too
    params: { environment: environment },
  )

  process_response(response)

  [response, deserialize(response, Puppet::Resource::Catalog)]
end

#put_facts(name, environment:, facts:) ⇒ Puppet::HTTP::Response

Submits a PUT request to submit facts for the node to the server.

Parameters:

  • name (String) —

    Name of the node we are submitting facts for

  • environment (String) —

    Name of the environment we are operating in

  • facts (Puppet::Node::Facts) —

    Facts for the named node

Returns:



155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
 
# File 'lib/puppet/http/service/compiler.rb', line 155

def put_facts(name, environment:, facts:)
  formatter = Puppet::Network::FormatHandler.format_for(Puppet[:preferred_serialization_format])

  headers = add_puppet_headers(
    'Accept' => get_mime_types(Puppet::Node::Facts).join(', '),
    'Content-Type' => formatter.mime
  )

  response = @client.put(
    with_base_url("/facts/#{name}"),
    serialize(formatter, facts),
    headers: headers,
    params: { environment: environment },
  )

  process_response(response)

  response
end

#put_filebucket_file(path, body:, environment:) ⇒ Puppet::HTTP::Response

Submit a PUT request to store a file with filebucket.

Parameters:

  • path (String) —

    The request path, formatted by Puppet::FileBucket::Dipper

  • body (String) —

    The contents of the file to be backed

  • environment (String) —

    Name of the environment we are operating in. This should not impact filebucket at all, but is included to be consistent with legacy code.

Returns:



225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
 
# File 'lib/puppet/http/service/compiler.rb', line 225

def put_filebucket_file(path, body:, environment:)
  headers = add_puppet_headers({
    'Accept' => 'application/octet-stream',
    'Content-Type' => 'application/octet-stream'
    })

  response = @client.put(
    with_base_url("/file_bucket_file/#{path}"),
    body,
    headers: headers,
    params: {
      environment: environment
    }
  )

  process_response(response)

  response
end