Module: EasyType::Type::ClassMethods

Defined in:
lib/easy_type/type.rb

Instance Method Summary collapse

Instance Method Details

#define_os_command_method(method_or_command) ⇒ Object 



224
225
226
227
228
229
 
# File 'lib/easy_type/type.rb', line 224

def define_os_command_method(method_or_command)
  eigenclass.send(:define_method, method_or_command) do | *args|
    command = args.dup.unshift(method_or_command)
    Puppet::Util::Execution.execute(command)
  end
end

#eigenclass ⇒ Object 



248
249
250
 
# File 'lib/easy_type/type.rb', line 248

def eigenclass
  class << self; self; end
end

#group(group_name = :default, &block) ⇒ Group

define a group of parameters. A group means a change in one of it’s members all the information in the group is added tot the command

rubocop:disable Alias

Examples:

group(:name) do # name is optional
   property :a
   property :b
end

Parameters:

  • group_name (Symbol) (defaults to: :default) —

    the group name to use. A group name must be unique within a type

Returns:

  • (Group) —

    the defined group



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
 
# File 'lib/easy_type/type.rb', line 81

def group(group_name = :default, &block)
  include EasyType::FileIncluder

  @group_name = group_name # make it global
  @groups ||= EasyType::Group.new

  alias :orig_parameter :parameter
  alias :orig_property :property

  def parameter(parameter_name)
    process_group_entry(include_file("puppet/type/#{name}/#{parameter_name}"))
  end

  def property(property_name)
    process_group_entry(include_file("puppet/type/#{name}/#{property_name}"))
  end

  def process_group_entry(entry)
    @groups.add(name, entry)
  end

  yield if block

  alias :parameter :orig_parameter
  alias :property :orig_property
end

#groups ⇒ Group

rubocop:enable Alias

Return the groups the type contains

Returns:

  • (Group) —

    All defined groups



113
114
115
116
 
# File 'lib/easy_type/type.rb', line 113

def groups
  @groups ||= EasyType::Group.new
  @groups
end

#map_title_to_attributes(*attributes) { ... } ⇒ Object

easy way to map parts of a title to one of the attributes and properties.

map_title_to_attributes([:name,:domain, :jmsmodule, :queue_name]) do

/^((.*\/)?(.*):(.*)?)$/)

end

You can also pass a Hash as one of the entries in the array. The key mus be the field to map to and the value mus be a closure (Proc or a Lambda) to manage the value

default_name = lambda {| name| name.nil? ? ‘default’ : name} map_title_to_attributes([:name -> default_name,:domain, :jmsmodule, :queue_name]) do

/^((.*\/)?(.*):(.*)?)$/)

end

Parameters:

  • an (Array) —

    array containing the symbols idetifying the parameters an properties to use

Yields:

  • yields regexp the regular expression to map parts of the title.



139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
 
# File 'lib/easy_type/type.rb', line 139

def map_title_to_attributes(*attributes)
  attribute_array = attributes.map  do | attr| 
    case attr
    when Array  then attr
    when Symbol then [attr, nil]
    when String then [attr.to_sym, nil]
    when Hash   then attr.to_a.flatten
    else fail "map_title_to_attribute, doesn\'t support #{attr.class} as attribute"
    end
  end
  regexp = yield
  eigenclass.send(:define_method,:title_patterns) do 
    [
      [
        regexp,
        attribute_array
      ]
    ]
  end
end

#on_create(&block) ⇒ Object

retuns the string needed to start the creation of an sql type

Examples:

newtype(:oracle_user) do

  on_create do
   "create user #{self[:name]}"
  end

Parameters:

  • block (Method) —

    The code to be run on creating a resource. Although the code customary returns just a string that is appended to the command, it can do anything that is deemed nesceccary.



266
267
268
 
# File 'lib/easy_type/type.rb', line 266

def on_create(&block)
  define_method(:on_create, &block) if block
end

#on_destroy(&block) ⇒ Object

retuns the string command needed to remove the specified type

Examples:

newtype(:oracle_user) do

  on_destroy do
   "drop user #{self[:name]}"
  end

Parameters:

  • block (Method) —

    The code to be run on destroying a resource. Although the code customary returns just a string that is appended to the command, it can do anything that is deemed nesceccary.



284
285
286
 
# File 'lib/easy_type/type.rb', line 284

def on_destroy(&block)
  define_method(:on_destroy, &block) if block
end

#on_modify(&block) ⇒ Object

retuns the string command needed to alter an sql type

Examples:

newtype(:oracle_user) do

  on_modify do
   "alter user #{self[:name]}"
  end

Parameters:

  • block (Method) —

    The code to be run on modifying a resource. Although the code customary returns just a string that is appended to the command, it can do anything that is deemed nesceccary.



302
303
304
 
# File 'lib/easy_type/type.rb', line 302

def on_modify(&block)
  define_method(:on_modify, &block) if block
end

#on_notify(&block) ⇒ Object

retuns the string needed to start the creation of an sql type

Examples:

newtype(:oracle_user) do

  on_refresh do
    # restart the server
  end

Parameters:

  • block (Method) —

    The code to be run on getting a notification



243
244
245
 
# File 'lib/easy_type/type.rb', line 243

def on_notify(&block)
  define_method(:refresh, &block) if block
end

#parameter(parameter_name) ⇒ Object Also known as: property

include’s the parameter declaration. It searches for the parameter file in the directory ‘puppet/type/type_name/parameter_name, or in the shared directory `puppet/type/shared`

Examples:

parameter(:name)

Parameters:

  • parameter_name (Symbol) —

    the base name of the parameter



169
170
171
 
# File 'lib/easy_type/type.rb', line 169

def parameter(parameter_name)
  process_group_entry(include_file("puppet/type/#{name}/#{parameter_name}"))
end

#process_group_entry(entry) ⇒ Object 



98
99
100
 
# File 'lib/easy_type/type.rb', line 98

def process_group_entry(entry)
  @groups.add(name, entry)
end

#set_command(methods_or_commands) ⇒ Object

set’s the command to be executed. If the specified argument translate’s to an existing class method on the type, this method will be identified as the command. When a class method doesn’t exist, the command will be translated to an os command

Examples:

newtype(:oracle_user) do

  command do
   :sql
  end

Parameters:

  • method_or_command (Symbol) —

    method or os command name



213
214
215
216
217
218
219
220
221
 
# File 'lib/easy_type/type.rb', line 213

def set_command(methods_or_commands)
  @commands ||= []
  methods_or_commands = Array(methods_or_commands) # ensure Array
  methods_or_commands.each do | method_or_command|
    method_or_command = method_or_command.to_s if RUBY_VERSION == '1.8.7'
    @commands << method_or_command
    define_os_command_method(method_or_command) unless methods.include?(method_or_command)
  end
end

#shared_file(parameter_name) ⇒ Object 



190
191
192
 
# File 'lib/easy_type/type.rb', line 190

def shared_file(parameter_name)
  get_ruby_file("puppet/type/shared/#{parameter_name}")
end

#shared_file?(parameter_name) ⇒ Boolean

Returns:

  • (Boolean) 


195
196
197
 
# File 'lib/easy_type/type.rb', line 195

def shared_file?(parameter_name)
  !shared_file(parameter_name).nil?
end

#specific_file(parameter_name) ⇒ Object 



180
181
182
 
# File 'lib/easy_type/type.rb', line 180

def specific_file(parameter_name)
  get_ruby_file("puppet/type/#{name}/#{parameter_name}")
end

#specific_file?(parameter_name) ⇒ Boolean

Returns:

  • (Boolean) 


185
186
187
 
# File 'lib/easy_type/type.rb', line 185

def specific_file?(parameter_name)
  !specific_file(parameter_name).nil?
end

#to_get_raw_resources(&block) ⇒ Object

The code in the block is called to fetch all information of all available resources on the system. Although not strictly necessary, it is a convention the return an Array of Hashes

Examples:

newtype(:oracle_user) do

  to_get_raw_resourced do
   TODO: Fill in
  end

Parameters:

  • block (Method) —

    The code to be run to fetch the raw resource information from the system.



319
320
321
 
# File 'lib/easy_type/type.rb', line 319

def to_get_raw_resources(&block)
  eigenclass.send(:define_method, :get_raw_resources, &block)
end