puppet 2.7.26 → 3.0.0.rc4

data/lib/puppet/indirector/json.rb

@@ -0,0 +1,76 @@
+require 'puppet/indirector/terminus'
+require 'puppet/util'
+
+# The base class for JSON indirection terminus implementations.
+#
+# This should generally be preferred to the YAML base for any future
+# implementations, since it is ~ three times faster despite being pure Ruby
+# rather than a C implementation.
+class Puppet::Indirector::JSON < Puppet::Indirector::Terminus
+  def find(request)
+    load_json_from_file(path(request.key), request.key)
+  end
+
+  def save(request)
+    filename = path(request.key)
+    FileUtils.mkdir_p(File.dirname(filename))
+
+    Puppet::Util.replace_file(filename, 0660) {|f| f.print to_json(request.instance) }
+  rescue TypeError => detail
+    Puppet.log_exception "Could not save #{self.name} #{request.key}: #{detail}"
+  end
+
+  def destroy(request)
+    File.unlink(path(request.key))
+  rescue => detail
+    unless detail.is_a? Errno::ENOENT
+      raise Puppet::Error, "Could not destroy #{self.name} #{request.key}: #{detail}"
+    end
+    1                           # emulate success...
+  end
+
+  def search(request)
+    Dir.glob(path(request.key)).collect do |file|
+      load_json_from_file(file, request.key)
+    end
+  end
+
+  # Return the path to a given node's file.
+  def path(name, ext = '.json')
+    if name =~ Puppet::Indirector::BadNameRegexp then
+      Puppet.crit("directory traversal detected in #{self.class}: #{name.inspect}")
+      raise ArgumentError, "invalid key"
+    end
+
+    base = Puppet.run_mode.master? ? Puppet[:server_datadir] : Puppet[:client_datadir]
+    File.join(base, self.class.indirection_name.to_s, name.to_s + ext)
+  end
+
+  private
+
+  def load_json_from_file(file, key)
+    json = nil
+
+    begin
+      json = File.read(file)
+    rescue Errno::ENOENT
+      return nil
+    rescue => detail
+      raise Puppet::Error, "Could not read JSON data for #{indirection.name} #{key}: #{detail}"
+    end
+
+    begin
+      return from_json(json)
+    rescue => detail
+      raise Puppet::Error, "Could not parse JSON data for #{indirection.name} #{key}: #{detail}"
+    end
+  end
+
+  def from_json(text)
+    model.convert_from('pson', text)
+  end
+
+  def to_json(object)
+    object.render('pson')
+  end
+end

data/lib/puppet/indirector/ldap.rb

@@ -68,8 +68,9 @@ class Puppet::Indirector::Ldap < Puppet::Indirector::Terminus
         conn.start
         @connection = conn.connection
       rescue => detail
-        puts detail.backtrace if Puppet[:trace]
-        raise Puppet::Error, "Could not connect to LDAP: #{detail}"
+        message = "Could not connect to LDAP: #{detail}"
+        Puppet.log_exception(detail, message)
+        raise Puppet::Error, message
       end
     end
 

data/lib/puppet/indirector/node/active_record.rb

@@ -7,6 +7,7 @@ class Puppet::Node::ActiveRecord < Puppet::Indirector::ActiveRecord
 
   def find(request)
     node = super
+    node.environment = request.environment
     node.fact_merge
     node
   end

data/lib/puppet/indirector/node/exec.rb

@@ -19,11 +19,20 @@ class Puppet::Node::Exec < Puppet::Indirector::Exec
     # Translate the output to ruby.
     result = translate(request.key, output)
 
+    # Set the requested environment if it wasn't overridden
+    # If we don't do this it gets set to the local default
+    result[:environment] ||= request.environment.name
+
     create_node(request.key, result)
   end
 
   private
 
+  # Proxy the execution, so it's easier to test.
+  def execute(command, arguments)
+    Puppet::Util::Execution.execute(command,arguments)
+  end
+
   # Turn our outputted objects into a Puppet::Node instance.
   def create_node(name, result)
     node = Puppet::Node.new(name)

data/lib/puppet/indirector/node/ldap.rb

@@ -35,7 +35,10 @@ class Puppet::Node::Ldap < Puppet::Indirector::Ldap
     names.each do |name|
       next unless info = name2hash(name)
 
-      break if node = info2node(request.key, info)
+      merge_parent(info) if info[:parent]
+      info[:environment] ||= request.environment.to_s
+      node = info2node(request.key, info)
+      break
     end
 
     node
@@ -56,6 +59,8 @@ class Puppet::Node::Ldap < Puppet::Indirector::Ldap
     ldapsearch(filter) { |entry| infos << entry2hash(entry, request.options[:fqdn]) }
 
     return infos.collect do |info|
+      merge_parent(info) if info[:parent]
+      info[:environment] ||= request.environment.to_s
       info2node(info[:name], info)
     end
   end
@@ -183,8 +188,6 @@ class Puppet::Node::Ldap < Puppet::Indirector::Ldap
 
   # Take a name and a hash, and return a node instance.
   def info2node(name, info)
-    merge_parent(info) if info[:parent]
-
     node = Puppet::Node.new(name)
 
     add_to_node(node, info)

data/lib/puppet/indirector/node/plain.rb

@@ -13,6 +13,7 @@ class Puppet::Node::Plain < Puppet::Indirector::Plain
   # Just return an empty node.
   def find(request)
     node = super
+    node.environment = request.environment
     node.fact_merge
     node
   end

data/lib/puppet/indirector/none.rb

@@ -0,0 +1,9 @@
+require 'puppet/indirector/terminus'
+
+# A none terminus type, meant to always return nil
+class Puppet::Indirector::None < Puppet::Indirector::Terminus
+  def find(request)
+    return nil
+  end
+end
+

data/lib/puppet/indirector/queue.rb

@@ -73,8 +73,7 @@ class Puppet::Indirector::Queue < Puppet::Indirector::Terminus
       begin
         yield(self.intern(msg))
       rescue => detail
-        puts detail.backtrace if Puppet[:trace]
-        Puppet.err "Error occured with subscription to queue #{queue} for indirection #{indirection_name}: #{detail}"
+        Puppet.log_exception(detail, "Error occured with subscription to queue #{queue} for indirection #{indirection_name}: #{detail}")
       end
     end
   end

data/lib/puppet/indirector/report/processor.rb

@@ -36,8 +36,7 @@ class Puppet::Transaction::Report::Processor < Puppet::Indirector::Code
         newrep.extend(mod)
         newrep.process
       rescue => detail
-        puts detail.backtrace if Puppet[:trace]
-        Puppet.err "Report #{name} failed: #{detail}"
+        Puppet.log_exception(detail, "Report #{name} failed: #{detail}")
       end
     end
   end
@@ -49,7 +48,7 @@ class Puppet::Transaction::Report::Processor < Puppet::Indirector::Code
   end
 
   def processors(&blk)
-    return [] if Puppet[:reports] == "none"
+    return if Puppet[:reports] == "none"
     reports.each do |name|
       if mod = Puppet::Reports.report(name)
         yield(mod)

data/lib/puppet/indirector/report/rest.rb

@@ -4,11 +4,5 @@ class Puppet::Transaction::Report::Rest < Puppet::Indirector::REST
   desc "Get server report over HTTP via REST."
   use_server_setting(:report_server)
   use_port_setting(:report_port)
-
-  private
-
-  def deserialize_save(content_type, body)
-    format = Puppet::Network::FormatHandler.protected_format(content_type)
-    format.intern(Array, body)
-  end
+  use_srv_service(:report)
 end

data/lib/puppet/indirector/request.rb

@@ -1,6 +1,8 @@
 require 'cgi'
 require 'uri'
 require 'puppet/indirector'
+require 'puppet/util/pson'
+require 'puppet/network/resolver'
 
 # This class encapsulates all of the information you need to make an
 # Indirection call, and as a a result also handles REST calls.  It's somewhat
@@ -14,6 +16,54 @@ class Puppet::Indirector::Request
 
   OPTION_ATTRIBUTES = [:ip, :node, :authenticated, :ignore_terminus, :ignore_cache, :instance, :environment]
 
+  # Load json before trying to register.
+  Puppet.features.pson? and ::PSON.register_document_type('IndirectorRequest',self)
+
+  def self.from_pson(json)
+    raise ArgumentError, "No indirection name provided in json data" unless indirection_name = json['type']
+    raise ArgumentError, "No method name provided in json data" unless method = json['method']
+    raise ArgumentError, "No key provided in json data" unless key = json['key']
+
+    request = new(indirection_name, method, key, nil, json['attributes'])
+
+    if instance = json['instance']
+      klass = Puppet::Indirector::Indirection.instance(request.indirection_name).model
+      if instance.is_a?(klass)
+        request.instance = instance
+      else
+        request.instance = klass.from_pson(instance)
+      end
+    end
+
+    request
+  end
+
+  def to_pson(*args)
+    result = {
+      'document_type' => 'IndirectorRequest',
+      'data' => {
+        'type' => indirection_name,
+        'method' => method,
+        'key' => key
+      }
+    }
+    data = result['data']
+    attributes = {}
+    OPTION_ATTRIBUTES.each do |key|
+      next unless value = send(key)
+      attributes[key] = value
+    end
+
+    options.each do |opt, value|
+      attributes[opt] = value
+    end
+
+    data['attributes'] = attributes unless attributes.empty?
+    data['instance'] = instance if instance
+
+    result.to_pson(*args)
+  end
+
   # Is this an authenticated request?
   def authenticated?
     # Double negative, so we just get true or false
@@ -49,27 +99,18 @@ class Puppet::Indirector::Request
     ignore_terminus
   end
 
-  def initialize(indirection_name, method, key_or_instance, options_or_instance = {})
-    if options_or_instance.is_a? Hash
-      options = options_or_instance
-      @instance = nil
-    else
-      options  = {}
-      @instance = options_or_instance
-    end
+  def initialize(indirection_name, method, key, instance, options = {})
+    @instance = instance
+    options ||= {}
 
     self.indirection_name = indirection_name
     self.method = method
 
-    set_attributes(options)
+    options = options.inject({}) { |hash, ary| hash[ary[0].to_sym] = ary[1]; hash }
 
-    @options = options.inject({}) { |hash, ary| hash[ary[0].to_sym] = ary[1]; hash }
+    set_attributes(options)
 
-    if key_or_instance.is_a?(String) || key_or_instance.is_a?(Symbol)
-      key = key_or_instance
-    else
-      @instance ||= key_or_instance
-    end
+    @options = options
 
     if key
       # If the request key is a URI, then we need to treat it specially,
@@ -150,15 +191,36 @@ class Puppet::Indirector::Request
     return(uri ? uri : "/#{indirection_name}/#{key}")
   end
 
-  def remote?
-    self.node or self.ip
+  def do_request(srv_service=:puppet, default_server=Puppet.settings[:server], default_port=Puppet.settings[:masterport], &block)
+    # We were given a specific server to use, so just use that one.
+    # This happens if someone does something like specifying a file
+    # source using a puppet:// URI with a specific server.
+    return yield(self) if !self.server.nil?
+
+    if Puppet.settings[:use_srv_records]
+      Puppet::Network::Resolver.each_srv_record(Puppet.settings[:srv_domain], srv_service) do |srv_server, srv_port|
+        begin
+          self.server = srv_server
+          self.port   = srv_port
+          return yield(self)
+        rescue SystemCallError => e
+          Puppet.warning "Error connecting to #{srv_server}:#{srv_port}: #{e.message}"
+        end
+      end
+    end
+
+    # ... Fall back onto the default server.
+    Puppet.debug "No more servers left, falling back to #{default_server}:#{default_port}" if Puppet.settings[:use_srv_records]
+    self.server = default_server
+    self.port   = default_port
+    return yield(self)
   end
 
   private
 
   def set_attributes(options)
     OPTION_ATTRIBUTES.each do |attribute|
-      if options.include?(attribute)
+      if options.include?(attribute.to_sym)
         send(attribute.to_s + "=", options[attribute])
         options.delete(attribute)
       end

data/lib/puppet/indirector/resource/active_record.rb

@@ -1,9 +1,6 @@
 require 'puppet/indirector/active_record'
-require 'puppet/indirector/resource/validator'
 
 class Puppet::Resource::ActiveRecord < Puppet::Indirector::ActiveRecord
-  include Puppet::Resource::Validator
-
   def search(request)
     type   = request_to_type_name(request)
     host   = request.options[:host]

data/lib/puppet/indirector/resource/ral.rb

@@ -1,8 +1,4 @@
-require 'puppet/indirector/resource/validator'
-
 class Puppet::Resource::Ral < Puppet::Indirector::Code
-  include Puppet::Resource::Validator
-
   def find( request )
     # find by name
     res   = type(request).instances.find { |o| o.name == resource_name(request) }

data/lib/puppet/indirector/resource/rest.rb

@@ -2,13 +2,4 @@ require 'puppet/indirector/status'
 require 'puppet/indirector/rest'
 
 class Puppet::Resource::Rest < Puppet::Indirector::REST
-
-  private
-
-  def deserialize_save(content_type, body)
-    # Body is [ral_res.to_resource, transaction.report]
-    format = Puppet::Network::FormatHandler.protected_format(content_type)
-    ary = format.intern(Array, body)
-    [Puppet::Resource.from_pson(ary[0]), Puppet::Transaction::Report.from_pson(ary[1])]
-  end
 end

data/lib/puppet/indirector/resource/store_configs.rb

@@ -1,6 +1,3 @@
 require 'puppet/indirector/store_configs'
-require 'puppet/indirector/resource/validator'
-
 class Puppet::Resource::StoreConfigs < Puppet::Indirector::StoreConfigs
-  include Puppet::Resource::Validator
 end

data/lib/puppet/indirector/resource_type/parser.rb

@@ -20,11 +20,40 @@ class Puppet::Indirector::ResourceType::Parser < Puppet::Indirector::Code
     nil
   end
 
+  # This is the "search" indirection method for resource types.  It searches
+  #  through a specified environment for all custom declared classes
+  #  (a.k.a 'hostclasses'), defined types (a.k.a. 'definitions'), and nodes.
+  #
+  # @param [Puppet::Indirector::Request] request
+  #   Important properties of the request parameter:
+  #   1. request.environment : The environment in which to look for types.
+  #   2. request.key : A String that will be treated as a regular expression to
+  #         be matched against the names of the available types.  You may also
+  #         pass a "*", which will match all available types.
+  #   3. request.options[:kind] : a String that can be used to filter the output
+  #         to only return the desired kinds.  The current supported values are
+  #         'class', 'defined_type', and 'node'.
   def search(request)
     krt = request.environment.known_resource_types
     # Make sure we've got all of the types loaded.
     krt.loader.import_all
-    result = [krt.hostclasses.values, krt.definitions.values, krt.nodes.values].flatten.reject { |t| t.name == "" }
+
+    result_candidates = case request.options[:kind]
+        when "class"
+          krt.hostclasses.values
+        when "defined_type"
+          krt.definitions.values
+        when "node"
+          krt.nodes.values
+        when nil
+          result_candidates = [krt.hostclasses.values, krt.definitions.values, krt.nodes.values]
+        else
+          raise ArgumentError, "Unrecognized kind filter: " +
+                    "'#{request.options[:kind]}', expected one " +
+                    " of 'class', 'defined_type', or 'node'."
+      end
+
+    result = result_candidates.flatten.reject { |t| t.name == "" }
     return nil if result.empty?
     return result if request.key == "*"
 

data/lib/puppet/indirector/rest.rb

@@ -19,188 +19,165 @@ class Puppet::Indirector::REST < Puppet::Indirector::Terminus
     @server_setting = setting
   end
 
-  def self.server
-    Puppet.settings[server_setting || :server]
-  end
-
   # Specify the setting that we should use to get the port.
   def self.use_port_setting(setting)
     @port_setting = setting
   end
 
-  def self.port
-    Puppet.settings[port_setting || :masterport].to_i
+  # Specify the service to use when doing SRV record lookup
+  def self.use_srv_service(service)
+    @srv_service = service
   end
 
-  # Provide appropriate headers.
-  def headers
-    add_accept_encoding({"Accept" => model.supported_formats.join(", ")})
+  def self.srv_service
+    @srv_service || :puppet
   end
 
-  def network(request)
-    Puppet::Network::HttpPool.http_instance(request.server || self.class.server, request.port || self.class.port)
+  def self.server
+    Puppet.settings[server_setting || :server]
   end
 
-  [:get, :post, :head, :delete, :put].each do |method|
-    define_method "http_#{method}" do |request, *args|
-      http_request(method, request, *args)
-    end
+  def self.port
+    Puppet.settings[port_setting || :masterport].to_i
   end
 
-  def http_request(method, request, *args)
-    http_connection = network(request)
-    peer_certs = []
-    verify_errors = []
-
-    http_connection.verify_callback = proc do |preverify_ok, ssl_context|
-      # We use the callback to collect the certificates for use in constructing
-      # the error message if the verification failed.  This is necessary since we
-      # don't have direct access to the cert that we expected the connection to
-      # use otherwise.
-      peer_certs << Puppet::SSL::Certificate.from_s(ssl_context.current_cert.to_pem)
-      # And also keep the detailed verification error if such an error occurs
-      if ssl_context.error_string and not preverify_ok
-        verify_errors << "#{ssl_context.error_string} for #{ssl_context.current_cert.subject}"
-      end
-      preverify_ok
-    end
+  # Figure out the content type, turn that into a format, and use the format
+  # to extract the body of the response.
+  def deserialize(response, multiple = false)
+    case response.code
+    when "404"
+      return nil
+    when /^2/
+      raise "No content type in http response; cannot parse" unless response['content-type']
 
-    http_connection.send(method, *args)
-  rescue OpenSSL::SSL::SSLError => error
-    if error.message.include? "certificate verify failed"
-      msg = error.message
-      msg << ": [" + verify_errors.join('; ') + "]"
-      raise Puppet::Error, msg
-    elsif error.message =~ /hostname (was )?not match/
-      raise unless cert = peer_certs.find { |c| c.name !~ /^puppet ca/i }
-
-      valid_certnames = [cert.name, *cert.subject_alt_names].uniq
-      msg = valid_certnames.length > 1 ? "one of #{valid_certnames.join(', ')}" : valid_certnames.first
-
-      raise Puppet::Error, "Server hostname '#{http_connection.address}' did not match server certificate; expected #{msg}"
-    elsif error.message.empty?
-      # This may be because the server is speaking SSLv2 and we
-      # monkey patch OpenSSL::SSL:SSLContext to reject SSLv2.
-      raise error.exception("#{error.class} with no message")
-    else
-      raise
-    end
-  end
+      content_type = response['content-type'].gsub(/\s*;.*$/,'') # strip any appended charset
 
-  def find(request)
-    uri, body = request_to_uri_and_body(request)
-    uri_with_query_string = "#{uri}?#{body}"
-    # WEBrick in Ruby 1.9.1 only supports up to 1024 character lines in an HTTP request
-    # http://redmine.ruby-lang.org/issues/show/3991
-    response = if "GET #{uri_with_query_string} HTTP/1.1\r\n".length > 1024
-      http_post(request, uri, body, headers)
-    else
-      http_get(request, uri_with_query_string, headers)
-    end
+      body = uncompress_body(response)
 
-    if is_http_200?(response)
-      content_type, body = parse_response(response)
-      result = deserialize_find(content_type, body)
-      result.name = request.key if result.respond_to?(:name=)
-      result
+      # Convert the response to a deserialized object.
+      if multiple
+        model.convert_from_multiple(content_type, body)
+      else
+        model.convert_from(content_type, body)
+      end
     else
-      nil
+      # Raise the http error if we didn't get a 'success' of some kind.
+      raise convert_to_http_error(response)
     end
   end
 
-  def head(request)
-    response = http_head(request, indirection2uri(request), headers)
+  def convert_to_http_error(response)
+    message = "Error #{response.code} on SERVER: #{(response.body||'').empty? ? response.message : uncompress_body(response)}"
+    Net::HTTPError.new(message, response)
+  end
 
-    !!is_http_200?(response)
+  # Provide appropriate headers.
+  def headers
+    add_accept_encoding({"Accept" => model.supported_formats.join(", ")})
   end
 
-  def search(request)
-    response = http_get(request, indirection2uri(request), headers)
+  def network(request)
+    Puppet::Network::HTTP::Connection.new(request.server || self.class.server, request.port || self.class.port)
+  end
 
-    if is_http_200?(response)
-      content_type, body = parse_response(response)
-      deserialize_search(content_type, body) || []
-    else
-      []
-    end
+  def http_get(request, *args)
+    http_request(:get, request, *args)
   end
 
-  def destroy(request)
-    raise ArgumentError, "DELETE does not accept options" unless request.options.empty?
+  def http_post(request, *args)
+    http_request(:post, request, *args)
+  end
 
-    response = http_delete(request, indirection2uri(request), headers)
+  def http_head(request, *args)
+    http_request(:head, request, *args)
+  end
 
-    if is_http_200?(response)
-      content_type, body = parse_response(response)
-      deserialize_destroy(content_type, body)
-    else
-      nil
-    end
+  def http_delete(request, *args)
+    http_request(:delete, request, *args)
   end
 
-  def save(request)
-    raise ArgumentError, "PUT does not accept options" unless request.options.empty?
+  def http_put(request, *args)
+    http_request(:put, request, *args)
+  end
 
-    response = http_put(request, indirection2uri(request), request.instance.render, headers.merge({ "Content-Type" => request.instance.mime }))
+  def http_request(method, request, *args)
+    conn = network(request)
+    conn.send(method, *args)
+  end
 
-    if is_http_200?(response)
-      content_type, body = parse_response(response)
-      deserialize_save(content_type, body)
-    else
-      nil
+  def find(request)
+    uri, body = request_to_uri_and_body(request)
+    uri_with_query_string = "#{uri}?#{body}"
+
+    response = do_request(request) do |request|
+      # WEBrick in Ruby 1.9.1 only supports up to 1024 character lines in an HTTP request
+      # http://redmine.ruby-lang.org/issues/show/3991
+      if "GET #{uri_with_query_string} HTTP/1.1\r\n".length > 1024
+        http_post(request, uri, body, headers)
+      else
+        http_get(request, uri_with_query_string, headers)
+      end
     end
-  end
+    result = deserialize(response)
 
-  def validate_key(request)
-    # Validation happens on the remote end
+    return nil unless result
+
+    result.name = request.key if result.respond_to?(:name=)
+    result
   end
 
-  private
+  def head(request)
+    response = do_request(request) do |request|
+      http_head(request, indirection2uri(request), headers)
+    end
 
-  def is_http_200?(response)
     case response.code
     when "404"
-      false
+      return false
     when /^2/
-      true
+      return true
     else
       # Raise the http error if we didn't get a 'success' of some kind.
       raise convert_to_http_error(response)
     end
   end
 
-  def convert_to_http_error(response)
-    message = "Error #{response.code} on SERVER: #{(response.body||'').empty? ? response.message : uncompress_body(response)}"
-    Net::HTTPError.new(message, response)
+  def search(request)
+    result = do_request(request) do |request|
+      deserialize(http_get(request, indirection2uri(request), headers), true)
+    end
+
+    # result from the server can be nil, but we promise to return an array...
+    result || []
   end
 
-  # Returns the content_type, stripping any appended charset, and the
-  # body, decompressed if necessary (content-encoding is checked inside
-  # uncompress_body)
-  def parse_response(response)
-    if response['content-type']
-      [ response['content-type'].gsub(/\s*;.*$/,''),
-        body = uncompress_body(response) ]
-    else
-      raise "No content type in http response; cannot parse"
+  def destroy(request)
+    raise ArgumentError, "DELETE does not accept options" unless request.options.empty?
+
+    do_request(request) do |request|
+      return deserialize(http_delete(request, indirection2uri(request), headers))
     end
   end
 
-  def deserialize_find(content_type, body)
-    model.convert_from(content_type, body)
-  end
+  def save(request)
+    raise ArgumentError, "PUT does not accept options" unless request.options.empty?
 
-  def deserialize_search(content_type, body)
-    model.convert_from_multiple(content_type, body)
+    do_request(request) do |request|
+      deserialize http_put(request, indirection2uri(request), request.instance.render, headers.merge({ "Content-Type" => request.instance.mime }))
+    end
   end
 
-  def deserialize_destroy(content_type, body)
-    model.convert_from(content_type, body)
+  # Encapsulate call to request.do_request with the arguments from this class
+  # Then yield to the code block that was called in
+  # We certainly could have retained the full request.do_request(...) { |r| ... }
+  # but this makes the code much cleaner and we only then actually make the call
+  # to request.do_request from here, thus if we change what we pass or how we
+  # get it, we only need to change it here.
+  def do_request(request)
+    request.do_request(self.class.srv_service, self.class.server, self.class.port) { |request| yield(request) }
   end
 
-  def deserialize_save(content_type, body)
-    nil
-  end
+  private
 
   def environment
     Puppet::Node::Environment.new