1. What is Grails?

Grails is an open-source web application framework that uses Groovy and is built on top of the Spring framework. It is designed to simplify web application development by leveraging the conventions-over-configuration philosophy and offering a high level of abstraction for common web development tasks. Grails promotes rapid application development (RAD) by using Groovy (a dynamic language running on the Java Virtual Machine, or JVM) and integrates tightly with the Spring ecosystem, which is a robust and widely used enterprise Java framework.

Grails is a full-stack framework that follows the model-view-controller (MVC) architecture, making it a powerful tool for building web applications quickly and efficiently. It allows developers to use Groovy to write concise code while still benefiting from the stability and reliability of the Java ecosystem. Since Grails is built on top of Spring and Hibernate, it naturally integrates with a wide range of Java libraries and tools, making it versatile for a variety of projects.

Grails is often compared to Ruby on Rails due to its similar design principles and focus on rapid development. It significantly reduces the amount of boilerplate code needed for building web applications, enabling developers to focus more on business logic than configuration.

Key Features of Grails:

• Built on Groovy and Spring: Grails combines the simplicity of Groovy with the power of the Spring framework, allowing developers to build robust and scalable applications quickly.
• Convention-over-Configuration: Grails uses sensible default conventions for configuration, meaning that developers can focus more on writing code and less on setting up configurations.
• Integrated ORM with GORM: Grails provides GORM (Grails Object-Relational Mapping), which simplifies the interaction with databases and is based on Hibernate.
• Dynamic and Flexible: Grails supports dynamic methods and closures through Groovy, making it a very flexible and expressive framework.
• Built-in Tools for Testing: Grails comes with built-in tools for testing and validation, including support for unit testing, integration testing, and functional testing.
• Plugin Ecosystem: Grails has a rich ecosystem of plugins, which developers can use to add functionality to their applications, ranging from authentication to integration with other systems.

2. Major Use Cases of Grails

Grails is a versatile framework suitable for building a wide range of web applications. Below are the major use cases where Grails excels:

2.1 Rapid Web Application Development

Grails is ideal for developers who need to quickly prototype or develop a full-featured web application. The framework’s convention-over-configuration approach means that developers can focus more on building functionality and less on setting up configurations. This makes Grails an excellent choice for building:

• Content Management Systems (CMS): Grails can be used to build scalable and customizable CMS platforms for websites, blogs, or enterprise applications.
• E-commerce Websites: The flexibility of Grails allows developers to build e-commerce platforms with custom features, integrated payment systems, and real-time inventory management.

2.2 RESTful APIs

Grails is a powerful choice for building RESTful APIs, which are crucial for modern web and mobile applications. Grails comes with built-in support for REST APIs, making it easy to create endpoints, manage request/response formats, and integrate with various data sources. It supports JSON and XML responses out of the box, and developers can easily customize how data is handled and returned.

• Mobile Application Backend: Grails makes it easy to build a backend for mobile applications, handling user authentication, data storage, and real-time communication with the frontend.
• Microservices: Grails’ integration with Spring Boot allows it to fit into a microservice architecture, where each service is responsible for a specific function and communicates via HTTP APIs.

2.3 Enterprise Applications

Due to Grails’ seamless integration with Spring and its support for robust database access through GORM, it is well-suited for enterprise-level applications. It is commonly used to build:

• Customer Relationship Management (CRM) systems that require integration with other enterprise tools and data sources.
• Business Intelligence (BI) and reporting tools that need to manage large datasets and generate reports.

2.4 Data-Driven Applications

Grails is an excellent choice for building data-driven applications that require complex data operations, reporting, and analysis. Its tight integration with Hibernate and GORM makes it easy to define complex relationships between objects and perform data manipulation operations.

How Grails Works Along with Architecture

Grails is built on the Model-View-Controller (MVC) architecture, which is one of the most widely adopted software design patterns for web applications. Here’s how Grails fits into the architecture of a web application:

3.1 The MVC Pattern

• Model: In Grails, the model represents the domain objects of the application, often interacting with a database. These models are typically defined as Groovy classes and are managed by the Grails ORM (GORM). The model handles data storage, retrieval, and business logic.
• View: Grails uses GSP (Groovy Server Pages) to define the views. GSP files are similar to JSP (JavaServer Pages) but use Groovy’s syntax to embed dynamic content. Views render the data sent from the controller and allow users to interact with the application.
• Controller: The controller acts as an intermediary between the model and the view. It listens for user requests, processes them (often interacting with the model), and returns the appropriate view. Grails controllers are defined as Groovy classes and handle tasks like routing, validation, and service orchestration.

3.2 Spring Framework Integration

Grails is tightly integrated with the Spring framework, which provides robust features for application development, including:

• Dependency Injection: Grails leverages Spring’s dependency injection capabilities, allowing objects to be automatically injected into controllers, services, and other components. This simplifies development and testing.
• Security: Grails includes Spring Security plugins for authentication and authorization, making it easy to secure applications.
• Transaction Management: Grails uses Spring’s transaction management for consistent handling of database transactions, ensuring that data is processed in a reliable and atomic manner.

3.3 GORM (Grails Object-Relational Mapping)

Grails’ ORM, GORM, abstracts away much of the complexity of interacting with relational databases. GORM simplifies database interactions by mapping domain classes to database tables, allowing developers to work with objects instead of writing SQL queries.

• Automatic Table Creation: Grails automatically generates database tables based on domain classes, which reduces the amount of manual database schema creation.
• Querying: GORM provides a set of dynamic methods for querying the database, reducing the need for verbose SQL. Developers can use Groovy’s dynamic capabilities to perform complex queries in a concise manner.

3.4 Plugin Architecture

Grails supports a plugin-based architecture, allowing developers to extend the functionality of their applications without having to write everything from scratch. Plugins are used to add features like:

• Authentication (e.g., Spring Security Plugin)
• File Upload (e.g., Grails File Uploader Plugin)
• Data Visualization (e.g., Grails Charting Plugin)

This extensibility helps Grails remain flexible and adaptable for various use cases and ensures that developers can leverage community-contributed plugins to accelerate development.

Basic Workflow of Grails

The workflow of developing a Grails application follows a logical, easy-to-understand pattern that includes setting up the environment, creating domain classes, defining controllers, creating views, and running the application. Here is a breakdown of the basic workflow:

4.1 Set Up Grails Environment

1. Install Grails: Grails is built on Groovy, so you need to install both Groovy and Grails. Grails can be installed via SDKMAN! or Homebrew (on macOS).
2. Create a New Project: Use Grails’ command-line tools to generate a new project. Run the following command to create a new Grails application:

grails create-app myapp

This will generate a basic Grails project structure with directories for controllers, views, and domain classes.

4.2 Create Domain Classes

3. Define Domain Models: In Grails, domain classes represent the objects in your application and are mapped to database tables using GORM. Create domain classes to represent the entities in your application.

class User {
    String username
    String password
}

4.3 Create Controllers

4. Add Controllers: Grails uses controllers to handle incoming HTTP requests, process data, and return views. A controller is responsible for managing the logic behind a specific set of actions.

class UserController {
    def index() {
        render view: 'index', model: [users: User.list()]
    }
}

4.4 Create Views

5. Design Views: Grails uses Groovy Server Pages (GSP) to render views. GSP is similar to JSP but uses Groovy syntax to embed dynamic content.

<g:each in="${users}" var="user">
    <p>${user.username}</p>
</g:each>

4.5 Run the Application

6. Start the Grails Server: Once the domain classes, controllers, and views are created, run the application using the Grails server:

grails run-app
The application will be hosted locally, usually at http://localhost:8080.

4.6 Test and Deploy

7. Test the Application: Grails provides built-in testing tools for unit testing, integration testing, and functional testing. Run tests to ensure that the application works as expected.
8. Deploy the Application: Once development and testing are complete, the Grails application can be packaged as a WAR file for deployment on a web server, or it can be deployed to cloud platforms such as Heroku, AWS, or Docker containers.

Step-by-Step Getting Started Guide for Grails

Step 1: Install Grails

1. Install SDKMAN! (if not already installed):

curl -s "https://get.sdkman.io" | bash

1. Install Grails using SDKMAN!:

sdk install grails

Step 2: Create a Grails Application

1. Generate a new Grails project:

grails create-app myapp

Step 3: Create Domain Classes

1. Create a domain class:

class Book {
    String title
    String author
}

Step 4: Create a Controller

1. Create a controller to handle HTTP requests:

class BookController {
    def index() {
        render view: 'index', model: [books: Book.list()]
    }
}

Step 5: Define Views Using GSP

1. Create a view in the grails-app/views directory to display the data:

<g:each in="${books}" var="book">
    <p>${book.title} by ${book.author}</p>
</g:each>

Step 6: Run the Application

1. Run the application using the command:

grails run-app

The post Mastering Grails: Use Cases, Architecture, Workflow, and Getting Started Guide appeared first on scmGalaxy.

Here are the List of way using you can apply grovy code in Jenkins

Method -1: Groovy plugin
This plugin adds the ability to directly execute Groovy code.
More info – https://wiki.jenkins.io/display/JENKINS/Groovy+plugin

Method -2: Jenkins script console
The inbuilt script console is a very useful and powerful Jenkins extension and ideally suits certain types of tasks. This simple but powerful built-in web console allows you to run Groovy scripts on your Jenkins instance (or its slave nodes) from directly within the user interface, and is installed as standard.

To access the console, either navigate to Manage Jenkins and then select Script Console, or simply append /script to your Jenkins host and port, like this for example: http://jenkinshost:8080/script
Running Script Console on the master
This feature can be accessed from “Manage Jenkins” > “Script Console”. Or visit the sub-URL /script on your Jenkins instance.

Running Script Console on agents
Visit “Manage Jenkins” > “Manage Nodes”. Select any node to view the status page. In the menu on the left, a menu item is available to open a “Script Console” on that specific agent.

More info – https://wiki.jenkins.io/display/JENKINS/Jenkins+Script+Console

Method -3: Scriptler Plugins
Scriptler allows you to store/edit groovy scripts and execute it on any of the slaves/nodes… no need to copy/paste groovy code anymore.
More Info – https://wiki.jenkins.io/display/JENKINS/Scriptler+Plugin

Reference

https://wiki.jenkins.io/display/JENKINS/Jenkins+Script+Console

The post How to run/execute groovy script in Jenkins? appeared first on scmGalaxy.

Here are the list of Groovy Script which can be used in Jenkins to automate the JOBs and CI process. Please add your list in the comment sections as well.

Main Source – 

• https://github.com/scmgalaxy/jenkins-groovy-script-example
• https://github.com/cloudbees/jenkins-scripts
• https://wiki.jenkins.io/display/JENKINS/Jenkins+Script+Console
• https://pghalliday.com/jenkins/groovy/sonar/chef/configuration/management/2014/09/21/some-useful-
• jenkins-groovy-scripts.html
• https://github.com/cloudbees/jenkins-scripts
• https://github.com/jenkinsci/jenkins-scripts
• https://gist.github.com/dnozay/e7afcf7a7dd8f73a4e05
• https://github.com/samrocketman/jenkins-bootstrap-shared
• https://github.com/samrocketman/jenkins-script-console-scripts

Example Groovy Script 

• Activate Chuck Norris Plugin — This script activates Chuck Norris plugin for all jobs in your Jenkins server
• Add a Maven Installation, Tool Installation, Modify System Config
• Add a new label to slaves meeting a condition — This script shows how to alter the slave nodes’ label membership. In this case we create a new label if the existing label contains a string. It has been tested from the Jenkins command window.
• Add notification plugin to every job — This script will add the Notification Plugin to every job.
• Allow broken build claiming on every jobs — With the following simple script, you can activate the option on every jobs of your server in just one go.
• Batch-Update Mercurial branch that is checked out — Updates for multiple jobs which branch will be checked out from Hg
• Bulk rename projects
• Change JVM Options in all Maven tasks of Freestyle Jobs — This script find all Maven Tasks registered in freestyle jobs and replace JVM Options by a new value.
• Change publish over SSH configuration
• Change SCMTrigger for each project to disable during the night and the week-end — This script lets you easily change all jobs running every minutes so that it gets disabled between 21:00 and 07:00 and on Saturday and Sunday.
• Change Version-Number in SVN-path
• Clone all projects in a View — This script enumerates all projects belonging to a specific view and clones them.
• Convert standard mail notifications to use the Mail-Ext Publisher plugin — This script replace mail notifications in all projects by Mail-Ext publisher plugin and re-uses existing recipients.
• Delete .tmp files left in workspace-files — This scripts deletes all the tmp files left in workspace-files directory after the build. On windows servers, this seems pretty common so we run this script on daily basis.
• Delete workspace for all disabled jobs — Deletes the workspace for all disabled jobs to save space
• Disable all jobs — This script disables all jobs in your Jenkins server
• Display Information About Nodes — This scripts displays a bunch of information about all the slave nodes.
• Display job parameters — This scripts displays the parameters for all the jobs along with their default values (if applicable).
• Display jobs group by the build steps they use
• Display list of projects that were built more than 1 day ago. — This script to display list of projects that were built more than 1 day ago.
• Display mail notifications recipients — This script displays for all jobs the list of mail recipients used for notifications.
• Display monitors status — Jenkins uses monitors to validate various behaviors. If you dismiss one, Jenkins will never propose you to reactivate it. This script allows you to check the status of all monitors and to reactive them.
• Display timer triggers — This scripts displays the timer triggers for all the jobs in order to better arrange them.
• Display Tools Location on All Nodes — This script can help to get Jenkins tools localtion on all your slaves
• Enable Timestamper plugin on all jobs — With the following simple script, you can activate the option on every jobs of your server in just one go.
• Failed Jobs — This scripts displays a list of all failed jobs. Addon: restart them.
• Find builds currently running that has been executing for more than N seconds
• Grant Cancel Permission for user and group that have Build permission — This script will go through all groups and users in both Global security and per job security settings.
• Invalidate Jenkins HTTP sessions — This script can monitor and invalidate HTTP sessions if there are many open ones on your server.
• Manually run log rotation on all jobs — Runs log rotation on all jobs to free space
• Monitor and Restart Offline Slaves — This script can monitor and restart offline nodes if they are not disconnected manually.
• Monitoring Scripts — Several scripts to display data about http sessions, threads, memory, JVM or MBeans, when using the Monitoring plugin.
• Parameterized System Groovy script — This script will demonstrate how to get parameters in a system groovy script.
• Preselect username in Maven Release Build
• Printing a list of credentials and their IDs
• Remove all disabled modules in Maven jobs — To remove all disabled modules in Maven jobs
• Remove Deployed Artifacts Actions — This script is used to remove the Deployed Artifacts list that is uselessly stored for each build by the Artifact Deployer Plugin.
• Remove Git Plugin BuildsByBranch BuildData — This script is used to remove the static list of BuildsByBranch that is uselessly stored for each build by the Git Plugin.
• Set GitBlitRepositoryBrowser with custum settings on all repos — This scripts allows to update the repo browser. Can be adapted to any other browser, not only gitblit.
• Update maven jobs to use the post build task to deploy artifacts — This script updates all maven jobs having a deploy goal by install and activate the post build step to deploy artifacts at the end of the build
• Update SVN Browser
• Wipe out workspaces of all jobs — This script wipes out the workspaces of all jobs on your Jenkins server
• Wipe workspaces for a set of jobs on all nodes — The script wipes workspaces of certain jobs on all nodes

The post Database of Groovy Script for Jenkins Automation appeared first on scmGalaxy.

if (“lower”.equals(CASE)){
def map = [product: stringValue.toLowerCase()]
return map
}

FATAL: No such property: CASE for class: Script1
groovy.lang.MissingPropertyException: No such property: CASE for class: Script1
at org.codehaus.groovy.runtime.ScriptBytecodeAdapter.unwrap(ScriptBytecodeAdapter.java:50)
at org.codehaus.groovy.runtime.callsite.PogoGetPropertySite.getProperty(PogoGetPropertySite.java:49)
at org.codehaus.groovy.runtime.callsite.AbstractCallSite.callGroovyObjectGetProperty(AbstractCallSite.java:231)
at Script1.run(Script1.groovy:1)
at groovy.lang.GroovyShell.evaluate(GroovyShell.java:580)
at groovy.lang.GroovyShell.evaluate(GroovyShell.java:618)
at groovy.lang.GroovyShell.evaluate(GroovyShell.java:589)
at org.jenkinsci.plugins.envinject.service.EnvInjectEnvVars.executeAndGetMapGroovyScript(EnvInjectEnvVars.java:142)
at org.jenkinsci.plugins.envinject.EnvInjectListener.setUpEnvironmentJobPropertyObject(EnvInjectListener.java:188)
at org.jenkinsci.plugins.envinject.EnvInjectListener.setUpEnvironment(EnvInjectListener.java:44)
at hudson.model.AbstractBuild$AbstractBuildExecution.createLauncher(AbstractBuild.java:575)
at hudson.model.AbstractBuild$AbstractBuildExecution.run(AbstractBuild.java:481)
at hudson.model.Run.execute(Run.java:1688)
at hudson.model.Run.run(Run.java:1635)
at com.cloudbees.plugins.flow.FlowRun.run(FlowRun.java:153)
at hudson.model.ResourceController.execute(ResourceController.java:88)
at hudson.model.Executor.run(Executor.java:231)
at hudson.model.OneOffExecutor.run(OneOffExecutor.java:43)
Regards,
Rajesh Kumar
Twitt me @ twitter.com/RajeshKumarIn

The post groovy.lang.MissingPropertyException: No such property: CASE for class appeared first on scmGalaxy.

The post Top 10 Scripting Languages in DevOps | List of Best Scripting Languages appeared first on scmGalaxy.