Making rest call from groovy

The Jenkins Continuous Delivery process has a strong Pipeline. Typically, Blue Ocean is used to automate the execution of workflows across that Pipeline. This automation requires communicating with other tools in the chain. Most tools today support Restful API calls as an integration point. Making Restful API calls from the Jenkins Groovy Pipeline script can be difficult since the version embedded in Jenkins can be limited in its functionality.

A quick and dirty way to make Restful API calls uses a script, curl, or wget. The elegant way uses Native Groovy. This works but is messy since you end up writing external scripts to wrapper command line calls or end up with many shell calls. If you use Groovy class files and move the coding from the Pipeline to the class, this will cleanup the Jenkins file and enable reuse. The Url and HttpUrlConnection classes enable the same functionality as HttpBuilder but you need to add more code to handle Headers and Cookie processing.

I created a new class that includes the Rest API code and my application level code. My Pipeline. Development","Move to Integration" ; println data[0] ; println data[1] ; The error checking and parsing are done in the class so the Jenkins file has to only be the driver of the Pipeline.

Look at the var folder for the full deployhub. No Comments. Share on Facebook Share. Share on Twitter Tweet. Share on LinkedIn Share. Share on Digg Share. Send email Mail. Reading Lists-A Compilation. Leave a Reply Cancel Reply My comment is. Contact Us: Phone: BoxCerrillos, NM Schedule a Demo: Want a tour?

Select a time that works for you on our shared calendar.Restful Web Service, expose API from your application in a secure, uniform, stateless manner to the calling client. The calling client can perform predefined operations using the Restful service. This formed the standard of how web services are implemented. Inthe web consortium also released the definition of an additional standard called RESTful.

Over the past couple of years, this standard has become quite popular. And is being used by many of the popular websites around the world which include Facebook and Twitter.

REST is a way to access resources which lie in a particular environment. For example, you could have a server that could be hosting important documents or pictures or videos. All of these are an example of resources. If a client, say a web browser needs any of these resources, it has to send a request to the server to access these resources.

Now REST defines a way on how these resources can be accessed. The key elements of a RESTful implementation are as follows: Resources — The first key element is the resource itself.

Let assume that a web application on a server has records of several employees. Request Verbs - These describe what you want to do with the resource.

A browser issues a GET verb to instruct the endpoint it wants to get data. Request Headers — These are additional instructions sent with the request. These might define the type of response required or the authorization details. Request Body - Data is sent with the request.

In a POST call, the client actually tells the web service that it wants to add a resource to the server. Hence, the request body would have the details of the resource which is required to be added to the server. Response Body — This is the main body of the response. Response Status codes — These codes are the general codes which are returned along with the response from the web server.The canonical reference for building a production grade API with Spring.

Since REST-assured uses Groovy under the hood, we actually have the opportunity to use raw Groovy syntax to create more powerful test cases. This is where the framework really comes to life. For the setup necessary to use REST-assured, check out our previous article. Let's start by taking a quick look at some basic Groovy concepts — with a few simple examples to equip us with just what we need.

In this example, we'll just pay attention to methodsclosures and the it implicit variable. Let's first create a Groovy collection of words:. Let's now create another collection out of the above with words with lengths that exceed four letters:.

Here, findAll is a method applied to the collection with a closure applied to the method. The method defines what logic to apply to the collection and the closure gives the method a predicate to customize the logic.

Making POST, PUT, DELETE Calls from Groovy

We're telling Groovy to loop through the collection and find all words whose length is greater than four and return the result into a new collection. The implicit variable it holds the current word in the loop. Finally, there is collectit calls the closure on each item in the collection and returns a new collection with the results of each.

Let's create a new collection out of the sizes of each item in the words collection:. We use sumas the name suggests to add up all elements in the collection. We can sum up the items in the sizes collection like so:. And if we want to verify that the odds with a status greater than 1 have prices 1. Since it has more than one item, we obtain a Groovy collection.

We then invoke the findAll method on this collection. The closure predicate tells Groovy to create another collection with JSON objects where status is greater than zero. We end our path with price which tells groovy to create another list of only prices of the odds in our previous list of JSON objects.REST is a way of thinking, not a protocol or standard.

It's a style of designing loosely coupled applications — more often than not, applications oriented for the Web — that rely on named resources rather than messages.

This tutorial guides you step-by-step through the fundamental concepts of REST and building applications with Restlets. You'll learn how to:. When you are done with the tutorial, you will understand the benefits of designing with RESTful principles, and you'll see how the Restlet framework makes it easy.

To get the most from this tutorial, you should be familiar with Java syntax and the basic concepts of object-oriented development on the Java platform. You should also be familiar with Web applications. To follow along and try out the code for this tutorial, you need a working installation of either:. There are two versions of the source code for this tutorial see Download. Readers with a low-bandwidth connection might prefer to download the Restlet framework, JUnit, XMLUnit, and DbUnit from their respective sites see Related topics and use the Download package version that does not include dependencies.

These requests map quite nicely to standard business-application needs such as create read, update, and delete CRUDas shown in Table By associating requests, which act like verbs, with resources, which act like nouns, you end up with a logical expression of behavior — GET this document and DELETE that record, for example.

Roy Fielding, the veritable father of REST, states in his PhD dissertation that REST "emphasizes scalability of component interactions, generality of interfaces, independent deployment of components, and intermediary components to reduce interaction latency, enforce security, and encapsulate legacy systems" see Related topics.

Building RESTful systems isn't difficult, and the systems are highly scalable while also being loosely coupled to the underlying data; they also leverage caching quite nicely.

Everything on the Web pages, images, and so on is in essence a resource.

making rest call from groovy

REST's reliance on named resources rather than messages facilitates loose coupling in application design, because it limits the exposure of the underlying technology. This URL represents a resource — an article called "Unambiguously analyzing metrics.

Subscribe to RSS

Notice that the URL is noun-based. Although you can also imagine associated, verb-based APIs — such as createArticle? In other words, they are not RESTful.

The beauty of REST is that resources can be anything, and how they are represented can vary too.

making rest call from groovy

It really doesn't matter. What matters is that a resource is named and that communication with it doesn't affect its state. Not affecting state is important because stateless interactions facilitate scalability. To quote Leonardo da Vinci, "simplicity is the ultimate sophistication. REST leverages the Web's simplicity and thus yields highly scalable, loosely coupled systems that, as it turns out, are simple to build.

making rest call from groovy

As you'll see, the hardest part of building a RESTful application is deciding on the resources you want to expose. Imagine an online application that manages races in which contestants run various distances such as the Chicago Marathon. The application manages races or events and the runners associated with them.

And it reports a particular runner's time how long it took to run the race and rank what place the runner finished in. The race-management company, Acme Racing, wants you to build a RESTful Web service that enables sponsors to create new races and racers for a particular race, and that can provide official results for a particular race.

Acme Racing already has a legacy fat-client application that supports similar requirements and leverages a simple database along with a domain model.As REST services continue to gain popularity you will be faced with question on whether or not you should make server side HTTP request or develop a native client.

It is similar to JdbcTemplate and JmsTemplate where these abstractions encapsulate lower level calls what can be performed with a library like apache http components. We will set up a project with spring boot and utilize the test class created. SparkFun is a neat product that allows people to push data to a public free location for consumption. So if you are looking for data or want the ability to store data via REST calls, this might be an option.

We found a data stream called Wimp Weather Station that provides weather readings from on top of somebody's roof in Colorado. Let's make a request to the URI and view the response as a String.

Creating a new class RestTemplate we will call getForEntity passing in a URL and the class we would like the response to be returned as. What we need to do is unwrap the json into multiple java objects which is tedious.

We next replace String. In the event that your service call fails or the marshaling of the json to the java object throws an exception you may want to log the error or retry the request. If you aren't familiar, the http response deliver a status codes which indicate whether a specific request has been successfully completed.

Luckily ResponseEntity adds the status code just for this reason. We will reference a status code enum constant and check the status code returned in the response.

If you receive a connection timed out exception, like the one below, it is quite possible that you are sitting behind a proxy. The snippet below should give you a reference. This screen cast is a high level simple configuration and just scratches the surface on how to make a http rest request in java.

As you are making this tutorial and implementing a solution be aware that this is just the tip of the iceberg so be sure to reach out to your web infrastructure teams.

Getting started As REST services continue to gain popularity you will be faced with question on whether or not you should make server side HTTP request or develop a native client.

Project set up [ ] We will set up a project with spring boot and utilize the test class created. Making a first request [ ] SparkFun is a neat product that allows people to push data to a public free location for consumption. Create wrapper objects What we need to do is unwrap the json into multiple java objects which is tedious.

ConnectException: Connection timed out: connect Caused by: java. ConnectException: Connection timed out: connect at java. Hope you enjoyed today's level uphave a great day!There are many techniques and frameworks for making micro-services on the JVM today.

making rest call from groovy

Some of them are well known, other less so. In this article I'm going to go through how you can leverage Groovy's expressiveness combined with the robust micro-service framework Ratpack to create services that consumes less resources and contains less boilerplate and annotations.

It is now roughly 6 years since I started exploring what Groovy can do. Since then Groovy has taken huge steps forward along with the JVM platform. Before there was Java 8, Kotlin, Scala and numerous other languages Groovy already had invented most functional paradigms the "new kids on the block" are so touting today.

While it was a bit slow still on Java 6, the introduction of invoke-dynamic in the JVM made it super-fast, almost as fast as Java itself making it a 1 language to use on the JVM.

I think Groovy's expressiveness combined with the low gradual learning curve if you are coming from Java makes it a perfect language to use both for configuration Gradle, Jenkins as well as application frameworks Grails, Ratpack.

Many programmers today are also getting tired of the annotation hell Java applications are becoming for example with Spring Framework where functionality is hidden behind a black box annotation.

Groovy's DSL support provides a nice simple alternative to annotations. Before we can begin, I need to introduce the star of the show, the Ratpack framework. I have now been using Ratpack for some time and it has started to grow more and more on me, turning out to be a great toolbox for writing Groovy based services.

Another strength of it is that it will be very lightweight since it will be running on the lightweight Netty server which is crucial if you are spinning up lots of services.

But, instead of you believing melet me show you how to make an app so you can judge for yourself. Since I like to keep examples relevant I will not write a "Hello world! I will show you how you can set up a in-memory H2 database as well as initialize it using Flyway scripts. Finally I will show you how to package and deploy it with Gradle to Docker. Sounds hard? I assure you if you can write a hello world app you can write what I just described in no time with Ratpack and Groovy.

We will start by creating our EP with Ratpack. So I create a new file called Ratpack. This is the main closure for any ratpack application. All logic to configure the ratpack app goes here.

Bindings in Ratpack are the equivalent of dependency injection in other frameworks. What you do is bind an interface or concrete class to an implementation of that class and then in your handlers you can get the implementation by only using the interface. In Ratpack this can be taken further to have multiple hierarchical registries with multiple implementations, but that is a more advanced topic for later. In our simple application we register two implementations; the H2Module and a anonymous service.

A module in Ratpack is a way to bundle functionality into an easily consumable form by Ratpack applications.Everything in the RESTful architecture is about resources.

You specify a resource in the URL of your request. For example, in the following URL —. The action that you are going to do on with a resource is set by the method verb written in upper case at the request start line.

For example, the following request start line —. The resource URL, headers and body which is called payload can include additional request parameters and data. The resource names, their hierarchy and parameters, supported methods, payload formats are not strictly defined. Technically, they should match the HTTP protocol, but the actual format to be used is yours.

To provide consumers of our API with information on available resources, methods, parameters and data formats, you may want to create your API specification. To ensure your API works properly, create functional tests that send requests to your API resources and validate responses. To view request contents in SoapUI, simply double-click the request in the Navigator panel on the left:. The editor toolbar displays the request method verbendpoint and resources names, and query parameters.

The left part of the editor displays the request contents, the right part displays response data. This view displays a table of the request parameters that are specified in the resource path, query string or headers. You can add and delete parameters, change their values and names in the table:.

The Style attribute indicates the parameter type where it is transferred to the server in the request URL or headers. Level specifies whether the parameter is added to the resource or to requests only. If the parameter is added a resource, all the methods and requests below the resource node in the Navigator will get this parameter. The Media Type box provides a number of standard media types for the request body, but you are free to enter any other value instead:.

For example, the following structure in the message body will result in the following Outline view:. Provides a nicer and more convenient input form for both request parameters and message body data:.

The ellipsis button opens a menu that helps you quickly insert project, test suite or test case properties into request parameters. For more information on authentication settings, please see SoapUI Pro documentation. Displays a list of custom headers to be added to the request. Use the toolbar items to add new custom headers or delete existing ones.

For example, the following items in the tab —.

Building RESTful Web Services with Groovy

Contains files to be attached to the simulated request as MIME attachments. For example:. On the image above, you can see the request that has two parameters both specifying file. The first just refers to a file in the file system hermes.


comments

Leave a Reply

Your email address will not be published. Required fields are marked *