I'm trying to set a variable for a key value pairing in a jenkinsfile and can't get it to recognize the variable as a string.
zip = "name_of_zip_file_to_use"
createZipFile = [src:"./test", destination:"./"+zip+".zip"]
I have tried to use the variable zip as the whole string also but nothing seems to work. I'm not sure why it isn't recognizing the destination value variable as a string. Any ideas why I can't get this to work in the jenkinsfile?
Referencing and interpolating variable is possible this way - using ${VARIABLE_NAME} syntax. So in your case it would look:
zip = "name_of_zip_file_to_use"
createZipFile = [src:"./test", destination:"./${zip}.zip"]
If interested more about referencing variables and/or a string concatenation, see docs or similar StackOverflow topics:
variable interpolation in groovy: https://www.jenkins.io/doc/book/pipeline/jenkinsfile/#string-interpolation and http://docs.groovy-lang.org/latest/html/documentation/#_string_interpolation
how to concatenate strings in a Jenkinsfile?
Related
I want to set vim plugin options that have the vimscript format let some#option = option inside my NeoVim init.lua file, but I can't figure out how to set these options in a format that NeoVim respects.
I've tried using vim.cmd("let some#option = option") but this doesn't seem to work. Any advice? Thanks!
From nanotee/nvim-lua-guide, the section on Managing vim internal variables shows various API calls, including
Global variables (g:):
vim.api.nvim_set_var()
vim.api.nvim_get_var()
vim.api.nvim_del_var()
In practice, setting a global variable looks like
vim.api.nvim_set_var('some#var', 'value')
You can also use the meta-accessors, such as vim.g:
vim.g['some#var'] = 'value'
The method with vmd.cmd can work, although using the more structured API shown above is advised.
Note that in vim.cmd("let some#option = option") the right-hand side of the assignment operator is an expression. This means the plain token option would be evaluated as an identifier.
Depending on what you are trying to do, you may need to add additional quotes to create a string.
vim.cmd("let some#var = 'value'")
I've run into a specific problem while trying to automate a tagging process in terraform. I've set an environment variable that is essentially a list of all the tags we'd be using for all resources provisioned in the apply. It looks like this...
export TF_VAR_taglist='{JiraEpic = "ETOS-56","AssignedResearcherPri" = "Isaac",AssignedResearcherSec = "Matt"}'
After setting the environment variable I added a variable called "taglist" in the variables.tf file that grabs the aforementioned environment variable. It looks like this...
variable "taglist"{}
Lastly, I have another locals.tf file where i set a common_tags variable. Like so...
locals { common_tags ="${var.taglist}" }
When i terraform apply, the build fails while trying to map the tags properly. This is the error i receive...
Error: Incorrect attribute value type
on kube_master_worker_nodes_ec2.tf line 9, in resource "aws_instance" "master":
9: tags = local.common_tags
|----------------
| local.common_tags is "{JiraEpic = \"ETOS-56\",AssignedResearcherPri = \"Isaac \",AssignedResearcherSec = \"Matt\"}"
Inappropriate value for attribute "tags": map of string required.
I then decided to define the type of the variable as map(string in the variables.tf file like this
variable "taglist"{ type = map(string) }
I had hoped that this would allow terraform to recognize this variable as a map of strings and not just a string literal, but I was wrong, and these are the errors I get when that definition is applied.
Error: Missing attribute separator
on <value for var.taglist> line 1:
(source code not available)
Expected a newline or comma to mark the beginning of the next attribute.
Error: No value for required variable
on variables.tf line 11:
11: variable "taglist"{
The root module input variable "taglist" is not set, and has no default value.
Use a -var or -var-file command line argument to provide a value for this
variable.
I'm really stuck on this, and I feel like I'm close. Can anyone provide some insight into this and how I should go about solving it?
I want to first thank Martin Atkins for giving me the idea of using colons instead of equal signs in my environment variable, because that was the ONLY issue. The variable was not properly represented as a JSON object so terraform was interpreting it as a string.
I changed
export TF_VAR_taglist='{JiraEpic = "ETOS-56","AssignedResearcherPri" = "Isaac",AssignedResearcherSec = "Matt"}'
to this
export TF_VAR_taglist='{"JiraEpic":"ETOS-56","AssignedResearcherPri":"Isaac", "AssignedResearcherSec":"Matt"}'
The build purrs like a kitten on catnip now.
Terraform uses the type constraint of a variable to decide how to interpret a string representation of its value. By default, Terraform will assume the value expects a primitive type such as a string or number, because that's the most typical case for variables set via the command line or environment variables.
Since your tag list is a list you need Terraform to interpret it as a map expression rather than as a string. You can tell Terraform to do that by telling Terraform which type of value you expect:
variable "taglist" {
type = map(string)
}
You can read more about this in the Terraform documentation section Complex-typed Values.
You then need to make sure that the value in the environment variable is a valid object expression in order to avoid a syntax error. If you're setting the environment variable from the shell command line then you need to be mindful of escaping/quoting to ensure that Terraform will see the value with all of the quotes intact, and without any extra metacharacters.
The result is often hard to read clearly, which is why the Terraform documentation recommends using a .tfvars file to set complex-typed variables, instead of the -var command line option or environment variables. However, since you are using automation you might find it easier to generate a .tfvars.json file instead, which uses standard JSON format and is therefore easier to generate using JSON libraries available in most programming languages. Here's the .tfvars.json equivalent of the value you showed in your question:
{
"taglist": {
"JiraEpic": "ETOS-56",
"AssignedResearcherPri": "Isaac",
"AssignedResearcherSec": "Matt"
}
}
Note that subjectively I'd find it pretty confusing to have a variable whose name ends in list when it actually expects a map. A more typical name for this variable would be just tags, though if it's useful to mention its type in order to distinguish it from other variables then I'd suggest tag_map instead, to make it less confusing.
Hi I need to pass a variable from select into the groovy script and I haven't a clue how to do it in variable bindings, anyone has an idea how to do it?
I tried with:
version=version
version=$version
version=${version}
version="${version}"
If you are going to use ${ ... } Notation you should enclose it double quotes, i.e.:
versionVar = "${version}"
The other think that keeps bothering me is that you are using the same variable name. I haven't tried but I think that using the same name you could are trying to use the same variable.
Where is the 'version' variable came from?
If you are trying to use Environment variables, then you should try like,
version = env.version
I have an environment variable injected by Jenkins like:
CUSTOMERS="foo,bar"
Now i need to loop over these values.
Is there any way to access these values AS items in ansible?
Any help including other suggestions how to to solve this is welcome.
You can pass in the environment variable to ansible with --extra-vars, but that's only part of the solution, you need to get the string value into a data format that ansible understands.
One straightforward option is to write a simple Python (or your preferred language) script to convert the environment variable to a JSON list and pass the JSON file to ansible as extra vars with --extra-vars "#customers.json" (JSON file input is available in ansible 1.3), see Ansible Variable documentation.
import sys
import os
import json
DEFAULT_VAR="CUSTOMERS"
def var_to_json(var_name, list_sep = ','):
var_dict = {var_name: os.environ[var_name].split(list_sep)}
return json.dumps(var_dict)
var_name=DEFAULT_VAR
if len(sys.argv) > 1:
var_name = sys.argv[1]
print var_to_json(var_name)
The script above could be generalized further (or customized to your situation). I'll have to leave it to you to hook the pieces together in your build environment.
Alternatively, as this previous answer explains, you can define a custom filter in ansible to process the input value. You could create a filter that converts the variable value to a list, then use the filter in your playbook when referencing the variable (presumably passed in via --extra-vars).
I see { } are used for closures, and then I believe when a $ is put in front of braces, it is simply doing a variable substitution within a string. I can't find the documentation on how the $ works in the reference ... hard to search on it unfortunately, and the Groovy String documentation is lacking in introducing this. Can you please point me to the documentation and/or explain the "$" operator in Groovy -- how all it can be used? Does Grails extend it at all beyond Groovy?
In a GString (groovy string), any valid Groovy expression can be enclosed in the ${...} including method calls etc.
This is detailed in the following page.
Grails does not extend the usage of $ beyond Groovy. Here are two practical usages of $
String Interpolation
Within a GString you can use $ without {} to evaluate a property path, e.g.
def date = new Date()
println "The time is $date.time"
If you want to evaluate an expression which is more complex than a property path, you must use ${}, e.g.
println "The time is ${new Date().getTime()}"
Dynamic Code Execution
Dynamically accessing a property
def prop = "time"
new Date()."$prop"
Dynamically invoking a method
def prop = "toString"
new Date()."$prop"()
As pointed out in the comments this is really just a special case of string interpolation, because the following is also valid
new Date().'toString'()
$ is not an operator in Groovy. In string substitution it identifies variables within the string - there's no magic there. It's a common format used for inline variables in many template and programming languages.
All special Groovy operators are listed here: http://groovy-lang.org/operators.html
Work in side Jenkins File in pipeline
#!/usr/bin/env groovy
node{
stage ('print'){
def DestPath="D\$\\"
println("DestPath:${DestPath}")
}
}