puppet-retrospec | generate puppet code tests modules facts types | Configuration Management library
kandi X-RAY | puppet-retrospec Summary
Support
Quality
Security
License
Reuse
- Ensure the module is valid
- This method returns a list of all files that should be included in the provider .
- Create AST for AST .
- = begin Function to create a module directory
- Returns the path to the templates directory
- Create a temporary module directory
- returns the type file if it exists
- Creates a puppet request object
- This method returns the list of sources for the template file .
puppet-retrospec Key Features
puppet-retrospec Examples and Code Snippets
Trending Discussions on Configuration Management
Trending Discussions on Configuration Management
QUESTION
I have a requirement where I need to check for a file on the puppet master and copy it to the agent only if it is not empty.
I have the following so far:
exec {
'check_empty_file':
provider => shell,
command => "test -s puppet:////path/to/puppetmaster/file",
returns => ["0", "1"],
}
if $check_empty_file == '0' {
file {
'file_name':
path => '/path/to/agent/file',
alias => '/path/to/agent/file',
source => "puppet:///path/to/puppetmaster/file",
}
}
But it doesn't work. Any help is appreciated. Thanks!
ANSWER
Answered 2020-Dec-17 at 02:50You cannot use an Exec resource to perform the check, because you need to perform the evaluation during catalog building, and resources are not applied until after the catalog is built. Moreover, the test command tests for the existence of a the specified path. It does not know about URLs, and even if it did, it would be unlikely to recognize or handle the puppet: URL scheme. Furthermore, there is no association whatever between resource titles and variable names.
To gather data at catalog building time, you're looking for a puppet function. It is not that hard to add your own custom function to Puppet, but you don't need that for your case -- the built-in file() function will serve your purpose. It might look something like this:
$file_content = file('/')
if $file_content != '' {
file { '/path/to/target/file':
ensure => 'file',
content => $file_content,
# ...
}
}
QUESTION
So for a hobby project of mine, I would like to create an application that translates an HTTP call and request between two services.
The application does that based on a configuration that can be set by the user. The idea is that the application listens to an incoming API call translates the call and then forwards it.
Then the application waits for a response then translates the response and sends it back to the caller.
A translation can be as simple as renaming a field value in a body object or replace a header field to the body.
I think a translation should begin with mapping the correct URL so here is an example of what I was thinking of a configuration should look like:
//request mapping
incoming URL = outgoing URL(
//Rename header value
header.someobject.renameto = "somevalue"
//Replace body object to header
body.someobject.replaceto.header
)
I was thinking that the configuration should be placed in a .txt file and read by the application.
My question is, are there other similar systems that use a configuration file for a configuration like this? And are there other/better ways to declare a configuration?
ANSWER
Answered 2020-Nov-10 at 11:42I have done something sort-of-similar in a different context (generate code from an input specification), so I will provide an outline of what I did to provide some food for thought. I used Config4* (disclosure: I developed that). If the approach I describe below is of interest to you, then I suggest you read Chapters 2 and 3 of the Config4* Getting Started Guide to get an overview of the Config4* syntax and API. Alternatively, express the concepts below in a different configuration syntax, such as XML.
Config4* is a configuration syntax, and the subset of syntax relevant to this discussion is as follows:
# this is a comment
name1 = "simple value";
name2 = ["a", "list of", "values"];
# a list can be laid out in columns to simulate a table of information
name3 = [
# item colour
#------------------
"car", "red",
"jeans", "blue",
"roses", "red",
];
In a code generator application, I used a table to provide rules to specify how to generate code for assigning values to fields of messages. If no rule was specified for a particular field, then some built-in rules provided default behaviour. The table looked something like the following:
field_rules = [
# wildcarded message.field instruction
#----------------------------------------------------------------
"Msg1.username", "@config:username",
"Msg1.password", "@config:password",
"Msg3.price", "@order:price",
"*.account", "@string:foobar",
"*.secondary_account", "@ignore",
"*.heartbeat_interval", "@expr:_heartbeatInterval * 1000",
"*.send_timestamp", "@now",
];
When my code generator wanted to generate code to assign a value to a field, the code generator constructed a string of the form ".", for example, Msg3.price. Then it examined the field_rules table line-by-line (starting from the top) to find a line in which the first column matched ".". The matching logic permitted * as a wildcard character that could match zero or more characters. (Conveniently, Config4* provides a patternMatch() utility operation that provides this functionality.)
If a match was found, then the value in the instruction column told the code generator what sort of code to generate. (If no match was found, then built-in rules were used, and if none of those applied, then no code was generated for the field.)
Each instruction was a string of the form "@:optional,arguments". That was tokenized to provide the keyword and the optional arguments. The keyword was converted to an enum, and that drove a switch statement for generating code. For example:
- The
@config:usernameinstruction specified that code should be generated to assign the value of theusernamevariable in a runtime configuration file to the field. - The
@order:priceinstruction specified that code should be generated to assign the value returned from callingorderObj->getPrice()to the field. - The
@string:foobarinstruction specified the string literalfoobarshould be assigned to the field. - The
@expr:_heartbeatInterval * 1000instruction specified that code should be generated to assign the value of the expression_heartbeatInterval * 1000to the field. - The
@ignoreinstruction specified that no code should be generated to assign a value to the field. - The
@nowinstruction specified that code should be generated to assign the current clock time to the field.
I have used the above technique in several projects, and each time I have invented instructions specific to the needs of the particular project. If you decide to use this technique, then obviously you will need to invent instructions to specify runtime translations rather than instructions to generate code. Also, don't feel you have to shoehorn all of your translation-based configuration into a single table. For example, you might use one table to provide a source URL -> destination URL mapping, and a different table to provide instructions for translating fields within messages.
If this technique works as well for you as it has worked for me on my projects, then you will end up with your translation application being an "engine" whose behaviour is driven entirely by a configuration file that, in effect, is a DSL (domain-specific language). That DSL file is likely to be quite compact (less than 100 lines), and will be the part of the application that is visible to users. Because of this, it is worthwhile investing effort to make the DSL as intuitive and easy-to-read/modify as possible, because doing that will make the translation application: (1) user friendly, and (2) easy to document in a user manual.
QUESTION
I have written separate playbooks for tomcat deployment on both Ubuntu and Linux as well, instead of mentioning **
when: ansible_distribution == 'Ubuntu'
**in every line in the playbook, i want to run the whole playbook only when this condition meets.
This is my code
- hosts: all
tasks:
- name: including the playbook for ubuntu deployment
include: tomcat_ubuntu_new.yaml
when: ansible_distribution == 'Ubuntu'
- name: including the playbook for ubuntu deployment
include: tomcat_standalone.yaml
when: ansible_distribution == 'CentOS' or ansible_distribution == 'RedHat'
Error:
ERROR! unexpected parameter type in action:
The error appears to be in '/etc/ansible/tomcat_ubuntu_new.yaml': line 3, column 3, but may
be elsewhere in the file depending on the exact syntax problem.
The offending line appears to be:
- hosts: all
^ here
I want to run the playbook only on the hosts based on the ansible_distribution
I tried many ways but no one works can any one post a clear answer with explanation
ANSWER
Answered 2020-Feb-10 at 14:44Q: "I want to run the playbook only on the hosts based on the ansible_distribution."
A: It's not possible to include a playbook. This would run the playbooks recursively.
Only import of a playbook is available. Moreover import_playbook is not a task. It's simply a tool to modularize large playbooks with multiple plays.
Ansible conditionals do not apply to import_playbook the same way as they do not apply to playbooks.
Instead, it is possible to create a group that will be used in the playbook.
$cat tomcat_ubuntu_new.yaml
---
- hosts: my_dynamic_group
tasks:
...
For example, let's create the group and import the playbook
---
- hosts: all
tasks:
- add_host:
name: "{{ item }}"
groups: my_dynamic_group
loop: "{{ groups.all }}"
when: hostvars[item].ansible_distribution == 'Ubuntu'
run_once: true
- import_playbook: tomcat_ubuntu_new.yaml
Community Discussions, Code Snippets contain sources that include Stack Exchange Network
Vulnerabilities
No vulnerabilities reported
Install puppet-retrospec
This will also install the retrospec framework that is required to use the plugin.
Support
Find, review, and download reusable Libraries, Code Snippets, Cloud APIs from over 650 million Knowledge Items
Find more librariesExplore Kits - Develop, implement, customize Projects, Custom Functions and Applications with kandi kits
Save this library and start creating your kit
Share this Page
