Bash script Request body is un-json-able - json

Im trying to push a data to an API,
for which I get the below error:
("Request body is not unjson()-able: %s" % body)
DirectException: Request body is not unjson()-able: '{"action":"EventsRouter","method":"add_event","data":[{"summary":"mes","device":"hos","message":"message","component":"sev","severity":"ap","evclasskey":"nxlog","evclass":"nxlog","monitor":"localhost"}],"type":"rpc","tid":2}'
current bash file:
#!/bin/bash
message=$1
hostname=$2
appname=$3
severity=$4
data='{"action":"EventsRouter","method":"add_event","data":[{"summary":"'$message'","device":"'$hostname'","message":"message","component":"'$appname'","severity":"'$severity'","evclasskey":"nxlog","evclass":"nxlog","monitor":"localhost"}],"type":"rpc","tid":2}'
echo "Total number of args : $#"
echo "message = $message"
echo "hostname = $hostname"
echo "appname = $appname"
echo "data = $data"
curl -u "Eve:eve#123" -k "https://myurl.com/zport/dmd/evconsole_router" -d "'$data'" -H "Content-Type:application/json"
First, What is the reason and how can i correct this. I am only sending simple values while testing:
sh tcp.sh mes hos sev ap
However, when i curl a data directly, it is working.
curl -u Eve:eve#123 -k https://myurl.com/zport/dmd/evconsole_router -d '{"action":"EventsRouter", "method":"add_event","data":[{"summary":"test","device":"test","message":"msg","component":"testhost","severity":"5", "evclasskey":"nxlog", "evclass":"/nxlog/perf","monitor":"localhost"}],"type":"rpc","tid":2}' -H "Content-Type:application/json"
{"uuid": "1654584c-5f86-489e-a5e7-35d45e462066", "action": "EventsRouter", "result": {"msg": "Created event", "success": true},"tid": 2, "type": "rpc", "method": "add_event"}
Secondly, This is about to be automated to read multiple log messages, if the log message has special characters such as ',",\,/, etc, will it affect my bash inputs?
If yes, how to I eliminate it?

can you please try this syntax and check the execution
data=$(cat <<EOF
{"action":"EventsRouter","method":"add_event","data":[{"summary":"$message","device":"$hostname","message":"message","component":"$appname","severity":"$severity","evclasskey":"nxlog","evclass":"nxlog","monitor":"localhost"}],"type":"rpc","tid":2}
EOF
)
Curl command syntax like
curl -u "Eve:eve#123" -k "https://myurl.com/zport/dmd/evconsole_router" -d "$data" -H "Content-Type:application/json"

Related

Can't create task scheduler with groovy script in nexus3.x

I want to create a script with helping of this document but I don't know how to pass a groovy file instead of json and when I execute
curl -u admin:admin123 -X POST --header 'Content-Type: application/json' \ ─╯
http://<url>/service/rest/v1/script \
-d create_task.groovy
I got this error:
{ "id" : "*", "message" : "Could not process the input:
Unrecognized token 'create_task': was expecting (JSON String, Number,
Array, Object or token 'null', 'true' or 'false')" }%
Any help would be appreciated!
enter code hereI found the solution!
you have to first convert that groovy script to a JSON file and pass that JSON file to your curl or API(for creating script) that you are working with and we can do it with this python file:
import json
with open("[THE GROOVY FILE]", "r") as inputfile:
filedata = inputfile.read()
jsondata = {}
jsondata['name'] = 'testscript2'
jsondata['type'] = 'groovy'
jsondata['content'] = filedata
with open("[OUTPUT FILE]", "w") as outputfile:
outputfile.write(json.dumps(jsondata))
the output file is something like this:
{
"name": "name",
"type": "groovy",
"content": "..."
}
then use this output file which is a JSON file and pass this to that command and there you go!
the command for creat script with REST API is:
curl -v -X POST -u admin:admin --header "Content-Type: application/json" "http://<url>/service/rest/v1/script" -d #{output}.json
the above command will create a script and you can execute it with:
curl -v -X POST -u admin:admin --header "Content-Type: application/json" "http://<url>/service/rest/v1/script/{name}/run

How to specify # in username and password for curl command?

$ curl -k -i -X POST -d '{ "path" : "/" }' https://abc#example.com:qwer##53096wrxgcg.ibmaspera.com:33001/files/workspaces/42796/all/12345:2
results in:
curl: (3) Port number ended with 'I'
Without #:
$ curl -k -i -X POST -d '{ "path" : "/" }' https://abcexample.com:qwer#53096wrxgcg.ibmaspera.com:33001/files/workspaces/42796/all/12345:2
results in:
curl: (7) Failed to connect to 53096wrxgcg.ibmaspera.com port 33001: Connection timed out
How to specify # in username and password for curl command?
If the auth username or password contain an # symbol, it should be urlencoded to %40.
Your curl command could look like either of these examples:
curl -k -i -X POST -d '{ "path" : "/" }' \
https://abc%40example.com:qwer%40#53096wrxgcg.ibmaspera.com:33001/files/workspaces/42796/all/12345:2
or
curl --user abc%40example.com:qwer%40 -k -i ...

Trying to Load A Message Payload from a JSON File in Bash to Send to Slack Channel

So I am trying to send a message to a specific slack channel using a secrets.json file to specify the payloads for both messages and the web-hook URL. I am able to post things to the message but it does not load the message as a payload even though the payload variable is set correctly. How can I load message payloads within the curl command I am specifying?
Here is the code:
richardbarret#1152-MBP  ~/Git/SalesforceCLI/Integration/Slack   master ●  ./automated_messages.sh  ✔  1488  10:48:42
https://hooks.slack.com/services/XXXXXXXXX/XXXXXXX/XXXXXX
Webhook Variable is Working.
invalid_payload% richardbarret#1152-MBP  ~/Git/SalesforceCLI/Integration/Slack   master ●  cat automated_messages.sh  ✔  1489  10:48:59
#!/bin/bash
# ===========================================================
# Created By: Richard Barrett
# Organization: Mirantis
# Department: Customer Success Operation
# Purpose: Send Message to Slack Channel
# Date: 03/20/2020
# ===========================================================
# System Variables
webhook_url=$(cat secrets.json | jq ".slack_config.slack_target_url" | tr -d \")
echo $webhook_url
printf "Webhook Variable is Working.\n"
message_1=$(cat secrets.json | jq ".slack_messages.message_1" | tr -d \")
message_2=$(cat secrets.json | jq ".slack_messages.message_2" | tr -d \")
message_3=$(cat secrets.json | jq ".slack_messages.message_3" | tr -d \")
# Use Messages in this command syntax
# Example
# curl -X POST -H 'Content-type: application/json' --data '{"text":"TEST TEXT BODY"}' $webhook_url
# General Message:
curl -X POST -H 'Content-type: application/json' --data '{"text":"$message_1"}' $webhook_url
# Messages for Handover:
#curl -X POST -H 'Content-type: application/json' --data '{"text":"Handovers: https://mirantis.my.salesforce.com/XXXXXXXXXXXXXXX"}' $webhook_url
# Message for All Change Requests:
#curl -X POST -H 'Content-type: application/json' --data '{"text":"All Change Requests: https://mirantis.my.salesforce.com/XXXXXXXXXXXX"}' $webhook_url
# Message for Change Requests in Ready to Execute
# curl -X POST -H 'Content-type: application/json' --data '{"text":"All CRs in Ready to Execute:"}' $webhook_url
I fixed the Invalid Payload because I forgot to use the "text": option within the --data so I know that is not the issue. When I run the above script all that get's posted it the following:
So I tried deleting the quotations around $message_1 and got the message:
Webhook Variable is Working.
invalid_payload%
I deleted the Webhook response because it has a slack token.
The webhook works, but the messages are not loading in the payload curl for the --data for some odd reason.
The secrets.json looks like this:
{
"slack_config": {
"slack_target_url": "https://hooks.slack.com/services/XXXXXXX/XXXXXXXXXXX/XXXXXXXXXXXXXXX"
},
"slack_messages": {
"message_1": "SLACK_MESSAGE_1 Testing Secrets Calls from secrets.json File",
"message_3": "SLACK_MESSAGE_3 Testing Secrets Calls from secrets.json File",
"message_2": "SLACK_MESSAGE_2 Testing Secrets Calls from secrets.json File"
}
}
So many thanks to one of my buddies who is an SRE, he was able to point me in the right direction. When trying to read something from a secrets.json it wasn't specifying the $message_1. But now if you replace the
--data '{"text":"$message_1"}'
with
--data "{\"text\":\"$message_1\"}"
you can then call the messages from within another file without exposing them.
This makes any links you may need to put in the message more secure as well as they are not hardcoded to the message.

Unable to push notification using parse

I try trigger below script and send notification to mobile using parse. Below is my script.
curl -X POST \
-H "X-Parse-Application-Id:app-id-here" \
-H "X-Parse-REST-API-Key:rest-key-here" \
-H "Content-Type: application/json" \
-d '{ "data": {"alert": "A test notification from Parse!"}}' \
https://api.parse.com/1/push
and i got error as below:
curl: (6) Could not resolve host: \ {"code":107,"error":"invalid json: { data: {alert:A"}
whats wrong with my json data?
So the main issue is that the 'script' needs to be on multiple lines if the backslash marks (\) are present, and there cannot be any spaces after backslashes. I've edited your question to format it correctly, and it works.. returning a better error.
{"code":115,"error":"Missing the push channels."}
You just need to alter the JSON to include a channel or a query to push to, based on the docs here: https://parse.com/docs/push_guide#sending-channels/REST
curl -X POST \
-H "X-Parse-Application-Id:app-id-here" \
-H "X-Parse-REST-API-Key:rest-key-here" \
-H "Content-Type: application/json" \
-d '{ "channels": ["Giants"], "data": {"alert": "A test notification from Parse!"}}' \
https://api.parse.com/1/push

How do I POST JSON data with cURL?

I use Ubuntu and installed cURL on it. I want to test my Spring REST application with cURL. I wrote my POST code at the Java side. However, I want to test it with cURL. I am trying to post a JSON data. Example data is like this:
{"value":"30","type":"Tip 3","targetModule":"Target 3","configurationGroup":null,"name":"Configuration Deneme 3","description":null,"identity":"Configuration Deneme 3","version":0,"systemId":3,"active":true}
I use this command:
curl -i \
-H "Accept: application/json" \
-H "X-HTTP-Method-Override: PUT" \
-X POST -d "value":"30","type":"Tip 3","targetModule":"Target 3","configurationGroup":null,"name":"Configuration Deneme 3","description":null,"identity":"Configuration Deneme 3","version":0,"systemId":3,"active":true \
http://localhost:8080/xx/xxx/xxxx
It returns this error:
HTTP/1.1 415 Unsupported Media Type
Server: Apache-Coyote/1.1
Content-Type: text/html;charset=utf-8
Content-Length: 1051
Date: Wed, 24 Aug 2011 08:50:17 GMT
The error description is this:
The server refused this request because the request entity is in a format not supported by the requested resource for the requested method ().
Tomcat log:
"POST /ui/webapp/conf/clear HTTP/1.1" 415 1051
What is the right format of the cURL command?
This is my Java side PUT code (I have tested GET and DELETE and they work):
#RequestMapping(method = RequestMethod.PUT)
public Configuration updateConfiguration(HttpServletResponse response, #RequestBody Configuration configuration) { //consider #Valid tag
configuration.setName("PUT worked");
//todo If error occurs response.sendError(HttpServletResponse.SC_NOT_FOUND);
return configuration;
}
You need to set your content-type to application/json. But -d (or --data) sends the Content-Type application/x-www-form-urlencoded, which is not accepted on Spring's side.
Looking at the curl man page, I think you can use -H (or --header):
-H "Content-Type: application/json"
Full example:
curl --header "Content-Type: application/json" \
--request POST \
--data '{"username":"xyz","password":"xyz"}' \
http://localhost:3000/api/login
(-H is short for --header, -d for --data)
Note that -request POST is optional if you use -d, as the -d flag implies a POST request.
On Windows, things are slightly different. See the comment thread.
Try to put your data in a file, say body.json and then use
curl -H "Content-Type: application/json" --data #body.json http://localhost:8080/ui/webapp/conf
For Windows, having a single quote for the -d value did not work for me, but it did work after changing to double quote. Also I needed to escape double quotes inside curly brackets.
That is, the following did not work:
curl -i -X POST -H "Content-Type: application/json" -d '{"key":"val"}' http://localhost:8080/appname/path
But the following worked:
curl -i -X POST -H "Content-Type: application/json" -d "{\"key\":\"val\"}" http://localhost:8080/appname/path
You might find resty useful:
It's a wrapper round CURL which simplifies command line REST requests. You point it to your API endpoint, and it gives you PUT and POST commands (Examples adapted from the homepage).
resty http://127.0.0.1:8080/data #Sets up resty to point at your endpoing
GET /blogs.json #Gets http://127.0.0.1:8080/data/blogs.json
#Put JSON
PUT /blogs/2.json '{"id" : 2, "title" : "updated post", "body" : "This is the new."}'
# POST JSON from a file
POST /blogs/5.json < /tmp/blog.json
Also, it's often still necessary to add the Content Type headers. You can do this once, though, to set a default, of add configuration files per-method per-site: Setting default RESTY options
It worked for me using:
curl -H "Accept: application/json" -H "Content-type: application/json" -X POST -d '{"id":100}' http://localhost/api/postJsonReader.do
It was happily mapped to the Spring controller:
#RequestMapping(value = "/postJsonReader", method = RequestMethod.POST)
public #ResponseBody String processPostJsonData(#RequestBody IdOnly idOnly) throws Exception {
logger.debug("JsonReaderController hit! Reading JSON data!"+idOnly.getId());
return "JSON Received";
}
IdOnly is a simple POJO with an id property.
You can use Postman to convert to CURL:
Note:
The latest Postman version has some UI upgrades and now the code link is available in the sidebar.
As an example, create a JSON file, params.json, and add this content to it:
[
{
"environment": "Devel",
"description": "Machine for test, please do not delete!"
}
]
Then you run this command:
curl -v -H "Content-Type: application/json" -X POST --data #params.json -u your_username:your_password http://localhost:8000/env/add_server
I just run into the same problem. I could solve it by specifying
-H "Content-Type: application/json; charset=UTF-8"
This worked well for me.
curl -X POST --data #json_out.txt http://localhost:8080/
Where,
-X Means the HTTP verb.
--data Means the data you want to send.
You can use Postman with its intuitive GUI to assemble your cURL command.
Install and Start Postman
Type in your URL, Post Body, Request Headers etc. pp.
Click on Code
Select cURL from the drop-down list
copy & paste your cURL command
Note: There are several options for automated request generation in the drop-down list, which is why I thought my post was neccessary in the first place.
HTTPie is a recommended alternative to curl because you can do just
http POST http://example.com/some/endpoint name=value name1=value1
It speaks JSON by default and will handle both setting the necessary header for you as well encoding data as valid JSON. There is also:
Some-Header:value
for headers, and
name==value
for query string parameters. If you have a large chunk of data, you can also read it from a file have it be JSON encoded:
field=#file.txt
Using CURL Windows, try this:
curl -X POST -H "Content-Type:application/json" -d "{\"firstName\": \"blablabla\",\"lastName\": \"dummy\",\"id\": \"123456\"}" http-host/_ah/api/employeeendpoint/v1/employee
TL;DR:
Use the holy trinity, jo + curl + jq (or fx):
jo value=30 type="Tip 3" targetModule="Target 3" configurationGroup=null name="Configuration Deneme 3" description=null identity="Configuration Deneme 3" | \
curl --json #- \
-X POST \
http://localhost:8080/xx/xxx/xxxx | \
jq
This will cover necessary headers that were missing: no need to explicitly define the Content-Type and Accept headers.
The new curl way with --json
Early March 2022, curl released a new command line parameter --json with version 7.82.0. This allows for a shortcut to send through JSON and eliminating the need to define the Content-Type that you had missing and Accept headers as these are automatically assumed, hence reducing risk of mistakes:
curl --json '{"tool": "curl"}' https://example.com/
But wait... there is more. Instead of defining the json parameter as a string to the curl command line, use the nifty jo CLI tool to define JSON as series of key value pairs and pipe the output through curl. Using jo only to define your JSON, it works this way:
> jo -p value=30 type="Tip 3" targetModule="Target 3" configurationGroup=null name="Configuration Deneme 3" description=null identity="Configuration Deneme 3"
version=0 systemId=3 active=true
{
"value": 30,
"type": "Tip 3",
"targetModule": "Target 3",
"configurationGroup": null,
"name": "Configuration Deneme 3",
"description": null,
"identity": "Configuration Deneme 3",
"version": 0,
"systemId": 3,
"active": true
}
Let's showcase this now with a similar curl command of yours but without extra headers and using jo + jq for nice output:
jo value=30 type="Tip 3" targetModule="Target 3" configurationGroup=null name="Configuration Deneme 3" description=null identity="Configuration Deneme 3" | \
curl --json #- \
-X POST \
http://localhost:8080/xx/xxx/xxxx | \
jq
Example with a free API
Using a free mock API for demonstration:
> jo title="Blog Post" body="lorem ipsum" userId=33 | \
curl --json #- \
-X POST \
https://jsonplaceholder.typicode.com/posts | \
jq
The output has a pretty format thanks to jq:
{
"title": "Blog Post",
"body": "lorem ipsum",
"userId": 33,
"id": 101
}
Use -d option to add payload
curl -X POST \
http://<host>:<port>/<path> \
-H 'Accept: application/json' \
-H 'Content-Type: application/json' \
-d '{
"foo": "bar",
"lorem": "ipsum"
}'
In addition:
use -X POST to use POST method
use -H 'Accept: application/json' to add accept type header
use -H 'Content-Type: application/json' to add content type header
If you're testing a lot of JSON send/responses against a RESTful interface, you may want to check out the Postman plug-in for Chrome (which allows you to manually define web service tests) and its Node.js-based Newman command-line companion (which allows you to automate tests against "collections" of Postman tests.) Both free and open!
This worked well for me, additionally using BASIC authentication:
curl -v --proxy '' --basic -u Administrator:password -X POST -H "Content-Type: application/json"
--data-binary '{"value":"30","type":"Tip 3","targetModule":"Target 3","configurationGroup":null,"name":"Configuration Deneme 3","description":null,"identity":"Configuration Deneme 3","version":0,"systemId":3,"active":true}'
http://httpbin.org/post
Of course, you should never use BASIC authentication without SSL and a checked certificate.
I ran into this again today, using Cygwin's cURL 7.49.1 for Windows... And when using --data or --data-binary with a JSON argument, cURL got confused and would interpret the {} in the JSON as a URL template. Adding a -g argument to turn off cURL globbing fixed that.
See also Passing a URL with brackets to curl.
You could also put your JSON content in a file and pass it to curl using the --upload-file option via standard input, like this:
echo 'my.awesome.json.function({"do" : "whatever"})' | curl -X POST "http://url" -T -
This worked for me:
curl -H "Content-Type: application/json" -X POST -d #./my_json_body.txt http://192.168.1.1/json
I had the issue of:
curl -X POST http://your-server-end-point -H "Content-Type: application/json"
-d #path-of-your-json-file.json
See, I did everything right. Only one thing - I missed "#" before the JSON file path.
I found one relevant go-to document on Internet - Common Options.
Here is another way to do it, if you have dynamic data to be included.
#!/bin/bash
version=$1
text=$2
branch=$(git rev-parse --abbrev-ref HEAD)
repo_full_name=$(git config --get remote.origin.url | sed 's/.*:\/\/github.com\///;s/.git$//')
token=$(git config --global github.token)
generate_post_data()
{
cat <<EOF
{
"tag_name": "$version",
"target_commitish": "$branch",
"name": "$version",
"body": "$text",
"draft": false,
"prerelease": false
}
EOF
}
echo "Create release $version for repo: $repo_full_name branch: $branch"
curl --data "$(generate_post_data)" "https://api.github.com/repos/$repo_full_name/releases?access_token=$token"
I am using the below format to test with a web server.
use -F 'json data'
Let's assume this JSON dict format:
{
'comment': {
'who':'some_one',
'desc' : 'get it'
}
}
Full example
curl -XPOST your_address/api -F comment='{"who":"some_one", "desc":"get it"}'
This worked for me for on Windows 10:
curl -d "{"""owner""":"""sasdasdasdasd"""}" -H "Content-Type: application/json" -X PUT http://localhost:8080/api/changeowner/CAR4
I made a tool called fetcher for this. It can send requests and format curl snippets:
Here's an example:
Example output:
curl -XGET -H "Accept: application/json" -d "{\"value\":\"30\",\"type\":\"Tip 3\",\"targetModule\":\"Target 3\",\"configurationGroup\":null,\"name\":\"Configuration Deneme 3\",\"description\":null,\"identity\":\"Configuration Deneme 3\",\"version\":0,\"systemId\":3,\"active\":true}" "http://localhost:8080/xx/xxx/xxxx"
For PowerShell I've used:
curl.exe -H "Content-Type: application/json" --data "#content.json" http://localhost:8080/appname/path
Where content.json was the name of the JSON file on my local containing the request, and curl.exe instead of just curl not to use the alias for Invoke-WebRequest.
Or if you want to specify directly the JSON:
curl.exe -H "Content-Type: application/json" --data '{\"username\":\"xyz\",\"password\":\"xyz\"}' http://localhost:8080/appname/path
-H to send something like content-type or an authentication token in the header
-d here adds your data
finally add a site link
Note: Don't forget to add an authentication token (if you have) for authentication credentials
curl -X POST -H 'Content-Type: application/json' -H 'Authorization: Token 2de403987713595a7955a9b4655b9e206d4294b3' -d '{"title":"Post test with curl", "body": "test body"}' http://127.0.0.1:8000/api/v1/feeds/
You can cat the contents of a JSON file to curl via the --data-raw parameter.
curl 'https://api.com/route' -H 'Content-Type: application/json' --data-raw "$(cat ~/.json/payload-2022-03-03.json | grep -v '^\s*//')"
Note: comments in the JSON file are filtered out via grep -v '^\s*//'
You can also pass the data to curl via standard input using grep or cat.
grep -v '^\s*//' ~/.json/payload-2022-03-03.json | curl 'https://api.com/route' -H 'Content-Type: application/json' -d #-
cat ~/.json/payload-2022-03-03.json | grep -v '^\s*//' | curl 'https://api.com/route' -H 'Content-Type: application/json' -d #-
The issue is here:
HTTP/1.1 415 Unsupported Media Type
Server Login can't interpret the Media Type of this request, so it is parsing it as text/html
The media type of any resource is declared in the Content-Type
property of the request header
"accept" ... header will fail this request, so the following is required for any JSON request to be sent i.e. content-type
-H 'content-type: application/json'
Suppose data and URL are something like this
{"email": "admin#admin.com","password": "123456"}
http://localhost:5000/api/login
Then in Linux
curl http://localhost:5000/api/login -H 'content-type: application/json' -d '{"email": "user#admin.com", "password": "123456"}'
In Windows (single quotes around parameters will not work)
curl http://localhost:5000/api/login -H "content-type: application/json" -d "{\"email\": \"user#admin.com\", \"password\": \"123456\"}"
-X POST key is not required when -d {.....} is present in command.
For a PUT request:
-X PUT
Based on Anand Rockzz's answer, here is what I did to this on GitHub Actions. It was a bit tricky due to the EOF tag.
My goal was to send an HTTP call once a Vercel deployment was finished (similar to a webhook).
This real-world example might help other people.
send-webhook-callback-once-deployment-ready:
name: Invoke webhook callback url defined by the customer (Ubuntu 18.04)
runs-on: ubuntu-18.04
needs: await-for-vercel-deployment
steps:
- uses: actions/checkout#v1 # Get last commit pushed - See https://github.com/actions/checkout
- name: Expose GitHub slug/short variables # See https://github.com/rlespinasse/github-slug-action#exposed-github-environment-variables
uses: rlespinasse/github-slug-action#v3.x # See https://github.com/rlespinasse/github-slug-action
- name: Expose git environment variables and call webhook (if provided)
# Workflow overview:
# - Resolves webhook url from customer config file
# - If a webhook url was defined, send a
run: |
MANUAL_TRIGGER_CUSTOMER="${{ github.event.inputs.customer}}"
CUSTOMER_REF_TO_DEPLOY="${MANUAL_TRIGGER_CUSTOMER:-$(cat vercel.json | jq --raw-output '.build.env.NEXT_PUBLIC_CUSTOMER_REF')}"
VERCEL_DEPLOYMENT_COMPLETED_WEBHOOK=$(cat vercel.$CUSTOMER_REF_TO_DEPLOY.staging.json | jq --raw-output '.build.env.VERCEL_DEPLOYMENT_COMPLETED_WEBHOOK')
# Checking if a webhook url is defined
if [ -n "$VERCEL_DEPLOYMENT_COMPLETED_WEBHOOK" ]; then
# Run script that populates git-related variables as ENV variables
echo "Running script populate-git-env.sh"
. ./scripts/populate-git-env.sh
echo "Resolved git variables:"
echo "'GIT_COMMIT_SHA': $GIT_COMMIT_SHA"
echo "'GIT_COMMIT_REF': $GIT_COMMIT_REF"
echo "'GIT_COMMIT_TAGS': $GIT_COMMIT_TAGS"
# Generates JSON using a bash function - See https://stackoverflow.com/a/57369772/2391795
# "End Of File" must be at the beginning of the line with no space/tab before or after - See https://stackoverflow.com/a/12909284/2391795
# But, when executed by GitHub Action, it must be inside the "run" section instead
generate_post_data() {
cat <<EOF
{
"MANUAL_TRIGGER_CUSTOMER": "${MANUAL_TRIGGER_CUSTOMER}",
"CUSTOMER_REF": "${CUSTOMER_REF_TO_DEPLOY}",
"STAGE": "staging",
"GIT_COMMIT_SHA": "${GIT_COMMIT_SHA}",
"GIT_COMMIT_REF": "${GIT_COMMIT_REF}",
"GIT_COMMIT_TAGS": "${GIT_COMMIT_TAGS}",
"GITHUB_REF_SLUG": "${GITHUB_REF_SLUG}",
"GITHUB_HEAD_REF_SLUG": "${GITHUB_HEAD_REF_SLUG}",
"GITHUB_BASE_REF_SLUG": "${GITHUB_BASE_REF_SLUG}",
"GITHUB_EVENT_REF_SLUG": "${GITHUB_EVENT_REF_SLUG}",
"GITHUB_REPOSITORY_SLUG": "${GITHUB_REPOSITORY_SLUG}",
"GITHUB_REF_SLUG_URL": "${GITHUB_REF_SLUG_URL}",
"GITHUB_HEAD_REF_SLUG_URL": "${GITHUB_HEAD_REF_SLUG_URL}",
"GITHUB_BASE_REF_SLUG_URL": "${GITHUB_BASE_REF_SLUG_URL}",
"GITHUB_EVENT_REF_SLUG_URL": "${GITHUB_EVENT_REF_SLUG_URL}",
"GITHUB_REPOSITORY_SLUG_URL": "${GITHUB_REPOSITORY_SLUG_URL}",
"GITHUB_SHA_SHORT": "${GITHUB_SHA_SHORT}"
}
EOF
}
echo "Print generate_post_data():"
echo "$(generate_post_data)"
echo "Calling webhook at '$VERCEL_DEPLOYMENT_COMPLETED_WEBHOOK'"
echo "Sending HTTP request (curl):"
curl POST \
"$VERCEL_DEPLOYMENT_COMPLETED_WEBHOOK" \
-vs \
--header "Accept: application/json" \
--header "Content-type: application/json" \
--data "$(generate_post_data)" \
2>&1 | sed '/^* /d; /bytes data]$/d; s/> //; s/< //'
# XXX See https://stackoverflow.com/a/54225157/2391795
# -vs - add headers (-v) but remove progress bar (-s)
# 2>&1 - combine stdout and stderr into single stdout
# sed - edit response produced by curl using the commands below
# /^* /d - remove lines starting with '* ' (technical info)
# /bytes data]$/d - remove lines ending with 'bytes data]' (technical info)
# s/> // - remove '> ' prefix
# s/< // - remove '< ' prefix
else
echo "No webhook url defined in 'vercel.$CUSTOMER_REF_TO_DEPLOY.staging.json:.build.env.VERCEL_DEPLOYMENT_COMPLETED_WEBHOOK' (found '$VERCEL_DEPLOYMENT_COMPLETED_WEBHOOK')"
fi
simple is that
curl -X POST https://localhost:3000/
-H "Content-Type: application/json"
-d '{"productId": 123456, "quantity": 100}'
--json <data> Sends the specified JSON data in a POST request to the HTTP server.
curl 7.82.0+
# Send a basic JSON object
curl --json '{"name":"xyz","breed":"xyz","age":100}' http://127.0.0.1:3000/cats
# letter #, read the data from a file
curl --json #cat.txt http://127.0.0.1:3000/cats
# letter -, read the data from stdin
echo '{"name":"xyz","breed":"xyz","age":100}' | curl --json #- http://127.0.0.1:3000/cats
curl 7.82.0-
curl -X POST --header "Content-Type: application/json" --data '{"name":"xyz","breed":"xyz","age":100}' http://127.0.0.1:3000/cats
https://curl.se/docs/manpage.html#--json