Class: Puppet::FileServing::Fileset

Inherits:
Object
  • Object
show all
Defined in:
lib/vendor/puppet/file_serving/fileset.rb

Overview

Operate recursively on a path, returning a set of file paths.

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(path, options = {}) ⇒ Fileset

Returns a new instance of Fileset.

Raises:

  • (ArgumentError) 


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
 
# File 'lib/vendor/puppet/file_serving/fileset.rb', line 57

def initialize(path, options = {})
  if Puppet.features.microsoft_windows?
    # REMIND: UNC path
    path = path.chomp(File::SEPARATOR) unless path =~ /^[A-Za-z]:\/$/
  else
    path = path.chomp(File::SEPARATOR) unless path == File::SEPARATOR
  end
  raise ArgumentError.new("Fileset paths must be fully qualified: #{path}") unless Puppet::Util.absolute_path?(path)

  @path = path

  # Set our defaults.
  @ignore = []
  @links = :manage
  @recurse = false
  @recurselimit = :infinite

  if options.is_a?(Puppet::Indirector::Request)
    initialize_from_request(options)
  else
    initialize_from_hash(options)
  end

  raise ArgumentError.new("Fileset paths must exist") unless stat = stat(path)
  raise ArgumentError.new("Fileset recurse parameter must not be a number anymore, please use recurselimit") if @recurse.is_a?(Integer)
end

Instance Attribute Details

#checksum_type ⇒ Object

Returns the value of attribute checksum_type.



8
9
10
 
# File 'lib/vendor/puppet/file_serving/fileset.rb', line 8

def checksum_type
  @checksum_type
end

#ignore ⇒ Object

Returns the value of attribute ignore.



7
8
9
 
# File 'lib/vendor/puppet/file_serving/fileset.rb', line 7

def ignore
  @ignore
end

#links ⇒ Object

Returns the value of attribute links.



7
8
9
 
# File 'lib/vendor/puppet/file_serving/fileset.rb', line 7

def links
  @links
end

#path ⇒ Object (readonly)

Returns the value of attribute path.



7
8
9
 
# File 'lib/vendor/puppet/file_serving/fileset.rb', line 7

def path
  @path
end

#recurse ⇒ Object

Returns the value of attribute recurse.



8
9
10
 
# File 'lib/vendor/puppet/file_serving/fileset.rb', line 8

def recurse
  @recurse
end

#recurselimit ⇒ Object

Returns the value of attribute recurselimit.



8
9
10
 
# File 'lib/vendor/puppet/file_serving/fileset.rb', line 8

def recurselimit
  @recurselimit
end

Class Method Details

.merge(*filesets) ⇒ Object

Produce a hash of files, with merged so that earlier files with the same postfix win. E.g., /dir1/subfile beats /dir2/subfile. It’s a hash because we need to know the relative path of each file, and the base directory.

This will probably only ever be used for searching for plugins.



15
16
17
18
19
20
21
22
23
24
25
 
# File 'lib/vendor/puppet/file_serving/fileset.rb', line 15

def self.merge(*filesets)
  result = {}

  filesets.each do |fileset|
    fileset.files.each do |file|
      result[file] ||= fileset.path
    end
  end

  result
end

Instance Method Details

#files ⇒ Object

Return a list of all files in our fileset. This is different from the normal definition of find in that we support specific levels of recursion, which means we need to know when we’re going another level deep, which Find doesn’t do.



31
32
33
34
35
36
37
38
39
40
41
42
 
# File 'lib/vendor/puppet/file_serving/fileset.rb', line 31

def files
  files = perform_recursion

  # Now strip off the leading path, so each file becomes relative, and remove
  # any slashes that might end up at the beginning of the path.
  result = files.collect { |file| file.sub(%r{^#{Regexp.escape(@path)}/*}, '') }

  # And add the path itself.
  result.unshift(".")

  result
end

#ignore?(path) ⇒ Boolean

Should we ignore this path?

Returns:

  • (Boolean) 


45
46
47
48
49
50
 
# File 'lib/vendor/puppet/file_serving/fileset.rb', line 45

def ignore?(path)
  return false if @ignore == [nil]

  # 'detect' normally returns the found result, whereas we just want true/false.
  ! @ignore.detect { |pattern| File.fnmatch?(pattern, path) }.nil?
end

#initialize_from_hash(options) ⇒ Object 



98
99
100
101
102
103
104
105
106
107
 
# File 'lib/vendor/puppet/file_serving/fileset.rb', line 98

def initialize_from_hash(options)
  options.each do |option, value|
    method = option.to_s + "="
    begin
      send(method, value)
    rescue NoMethodError
      raise ArgumentError, "Invalid option '#{option}'"
    end
  end
end

#initialize_from_request(request) ⇒ Object 



109
110
111
112
113
114
115
116
117
118
119
120
121
122
 
# File 'lib/vendor/puppet/file_serving/fileset.rb', line 109

def initialize_from_request(request)
  [:links, :ignore, :recurse, :recurselimit, :checksum_type].each do |param|
    if request.options.include?(param) # use 'include?' so the values can be false
      value = request.options[param]
    elsif request.options.include?(param.to_s)
      value = request.options[param.to_s]
    end
    next if value.nil?
    value = true if value == "true"
    value = false if value == "false"
    value = Integer(value) if value.is_a?(String) and value =~ /^\d+$/
    send(param.to_s + "=", value)
  end
end

#recurse?(depth) ⇒ Boolean

Should we recurse further? This is basically a single place for all of the logic around recursion.

Returns:

  • (Boolean) 


93
94
95
96
 
# File 'lib/vendor/puppet/file_serving/fileset.rb', line 93

def recurse?(depth)
  # recurse if told to, and infinite recursion or current depth not at the limit
  self.recurse and (self.recurselimit == :infinite or depth <= self.recurselimit)
end

#stat(path) ⇒ Object

Stat a given file, using the links-appropriate method.



162
163
164
165
166
167
168
169
170
171
172
 
# File 'lib/vendor/puppet/file_serving/fileset.rb', line 162

def stat(path)
  @stat_method ||= self.links == :manage ? :lstat : :stat

  begin
    return File.send(@stat_method, path)
  rescue
    # If this happens, it is almost surely because we're
    # trying to manage a link to a file that does not exist.
    return nil
  end
end