Data integration is a critical process for businesses that need to unify data from multiple sources into a single, cohesive framework. These tools help streamline data ingestion, transformation, and synchronization across different platforms, ensuring data consistency and accessibility. Below is a list of the top 21 data integration tools along with their key features and benefits.

1. Apache Nifi

Apache Nifi is an open-source data integration tool that provides real-time data movement, transformation, and automation. It offers a user-friendly interface for data flow management and supports various data sources. With built-in data provenance tracking, Apache Nifi ensures end-to-end visibility of data movement, allowing organizations to monitor and debug data flows effectively.

2. Talend Data Integration

Talend provides a robust ETL (Extract, Transform, Load) platform that supports batch and real-time data integration. It offers cloud-native and on-premise solutions, data governance, and quality management capabilities. Talend also provides machine learning-based data quality checks, ensuring clean and accurate data for analytics and business intelligence.

3. Informatica PowerCenter

Informatica PowerCenter is a leading data integration tool that allows organizations to connect and manage large-scale data pipelines. It offers advanced ETL functionality, automation, and AI-driven metadata management. With its high-speed data transformation engine, Informatica PowerCenter can process massive datasets efficiently while maintaining data integrity.

4. Microsoft Azure Data Factory

Azure Data Factory is a cloud-based ETL and data integration service that enables users to build, orchestrate, and monitor data pipelines across multiple cloud and on-premises sources. It provides over 90 built-in connectors, supporting seamless integration with SQL databases, cloud storage, and enterprise applications.

5. IBM InfoSphere DataStage

IBM InfoSphere DataStage is an enterprise-class ETL tool that helps organizations integrate, transform, and move data across various sources. It provides high-speed parallel processing for large data workloads. The tool also includes AI-powered automation for schema detection, enhancing efficiency in data transformation.

6. Google Cloud Data Fusion

Google Cloud Data Fusion is a fully managed, cloud-native ETL and data integration platform that enables organizations to create, monitor, and manage data pipelines with minimal coding. It supports extensive data lineage tracking and integrates seamlessly with Google BigQuery, AI/ML services, and Google Cloud Storage.

7. AWS Glue

AWS Glue is a serverless ETL service that simplifies data preparation and integration for analytics. It provides automatic schema discovery, job scheduling, and seamless integration with other AWS services. AWS Glue’s machine learning-based data cataloging capabilities allow businesses to automate metadata management and enhance data governance.

8. SnapLogic

SnapLogic is an intelligent data integration tool that uses AI-powered automation to connect applications, databases, and cloud platforms. It supports real-time and batch data processing. SnapLogic’s pre-built connectors and drag-and-drop interface make it a highly efficient tool for rapid data pipeline development.

9. Dell Boomi

Dell Boomi is a cloud-based integration platform as a service (iPaaS) that offers API management, workflow automation, and master data management (MDM) to connect cloud and on-premises applications. Its low-code design accelerates data integration and helps businesses unify their data ecosystems.

10. MuleSoft Anypoint Platform

MuleSoft Anypoint Platform is a powerful integration tool that provides API-led connectivity to unify applications, data, and devices across hybrid cloud environments. It offers pre-built templates and reusable assets to accelerate the integration of enterprise applications.

11. Oracle Data Integrator (ODI)

Oracle Data Integrator (ODI) is a high-performance ELT (Extract, Load, Transform) tool that automates data integration processes. It supports real-time data replication and transformation. ODI also provides seamless integration with Oracle Cloud Infrastructure, enhancing performance and scalability.

12. Matillion

Matillion is a cloud-native ETL tool that simplifies data integration for modern cloud data warehouses like Snowflake, Amazon Redshift, and Google BigQuery. With its easy-to-use interface and automated workflows, Matillion helps data teams speed up analytics processing.

13. Fivetran

Fivetran is an automated data pipeline tool that provides continuous, real-time data synchronization between databases, cloud services, and analytics platforms. It features automatic schema evolution, ensuring minimal maintenance for data engineers.

14. Apache Kafka

Apache Kafka is a distributed event streaming platform that enables real-time data integration and processing. It is widely used for building scalable and fault-tolerant data pipelines. Kafka’s distributed nature allows businesses to handle high-throughput event-driven architectures with ease.

15. CloverDX

CloverDX is a data integration and transformation platform that helps businesses design, automate, and manage complex data workflows. It provides an intuitive visual development environment and supports both batch and real-time data processing.

16. Stitch

Stitch is a cloud-first ETL tool that enables fast and secure data replication from multiple sources into data warehouses with minimal configuration. Stitch provides built-in monitoring and automated error handling to ensure reliable data pipelines.

17. Qlik Replicate

Qlik Replicate simplifies data integration by providing real-time data replication, change data capture (CDC), and automated schema management. It is widely used for ensuring high availability and business continuity through efficient data synchronization.

18. Alooma

Alooma, a part of Google Cloud, is an ETL tool that allows businesses to integrate streaming and batch data from various sources into Google BigQuery. It provides real-time data validation, ensuring high data quality and consistency.

19. TIBCO Cloud Integration

TIBCO Cloud Integration is a scalable iPaaS solution that provides API management, event-driven architecture, and real-time data synchronization across multiple environments. It allows seamless connectivity across on-premise, cloud, and SaaS applications.

20. Hevo Data

Hevo Data is a no-code data integration platform that enables real-time data transfer between multiple sources and destinations with automation and monitoring features. Hevo supports data enrichment and provides in-depth error logging for efficient debugging.

21. Pentaho Data Integration (PDI)

Pentaho Data Integration (PDI) is an open-source ETL tool that allows businesses to extract, cleanse, and load data into different databases and analytics platforms. It supports big data processing and integrates with machine learning frameworks for advanced analytics.

Conclusion

These 21 data integration tools provide essential features for businesses looking to streamline data movement, transformation, and synchronization across multiple systems. Whether you need cloud-based ETL, real-time event streaming, or AI-powered automation, selecting the right tool depends on your organization’s specific data integration needs and scalability requirements. Choosing the best tool ensures efficient data flow, enhanced data governance, and better business decision-making.

The post Top 21 Tools for Data Integration Tools in 2026 appeared first on scmGalaxy.

1. JUnit

JUnit is a widely used testing framework for Java applications. It is primarily used for unit testing but can also be used for integration testing, particularly when testing how different components of a Java application interact. JUnit provides annotations, assertions, and other utilities to help create robust test cases. It integrates seamlessly with build tools like Maven and Gradle, and continuous integration platforms like Jenkins, making it a go-to tool for Java developers.

2. TestNG

TestNG is a testing framework inspired by JUnit but designed to overcome some of its limitations. It is particularly popular for integration testing due to its flexibility and support for parallel test execution, allowing multiple tests to run simultaneously on different systems. TestNG supports a wide range of annotations and can be easily integrated with other tools like Jenkins, Maven, and Ant, making it suitable for large-scale testing environments. It’s widely used in Java projects for both unit and integration testing.

3. Postman

Postman is a popular tool used for API testing, making it an excellent choice for integration testing of web services. It provides a user-friendly interface for sending HTTP requests and validating responses, including status codes, headers, and body content. Postman allows users to group requests into collections, automate tests using JavaScript, and run tests in different environments. Its ability to automate API tests and integrate with CI/CD tools makes it ideal for API-based integration testing.

4. Apache Camel

Apache Camel is an open-source integration framework that provides a rule-based routing and mediation engine. It allows integration testing of various components in complex systems. Camel supports different protocols and data formats, making it versatile for integration testing across heterogeneous environments. Its built-in testing features, such as mock components and unit testing capabilities, make it easy to test integrations before going live.

5. WireMock

WireMock is a tool for simulating HTTP-based services. It’s primarily used for testing integrations with third-party APIs and web services when those services are unavailable, or when testing needs to be done in isolation. WireMock can simulate server responses for different HTTP methods, return specific data, and introduce delays or failures to test error handling in integration scenarios. It is often used to mock RESTful web services during integration testing.

6. Spring Test

Spring Test is part of the larger Spring Framework and provides comprehensive testing support for Spring-based applications. It allows for testing of Spring’s various components, including services, controllers, and repositories, as well as complete integration testing of the application. Spring Test includes features for context loading, transaction management, and mock objects, helping developers test how different parts of their Spring applications interact in real-world scenarios.

7. Cucumber

Cucumber is a widely-used BDD (Behavior-Driven Development) tool that allows for integration testing in an easy-to-understand, natural language format. Test cases are written in Gherkin, a domain-specific language that is understandable by both technical and non-technical stakeholders. Cucumber integrates with a variety of programming languages and testing frameworks, including Java and Ruby, and it is ideal for testing complex integrations between systems in a way that is easily understandable.

8. Selenium

Selenium is a popular tool for automating web applications, commonly used for functional and integration testing of web apps. Selenium allows testers to write tests in various programming languages such as Java, Python, and Ruby, and test how different components of a web application interact with each other. It can simulate user actions, test web services, and validate the interaction between front-end and back-end systems, making it ideal for integration testing in web applications.

9. FitNesse

FitNesse is a framework for acceptance testing that is particularly useful for integration testing. It is designed to support collaboration between developers, testers, and business stakeholders. FitNesse allows tests to be written in a wiki-style format, and it integrates with Java and other programming languages to perform integration tests. Its main advantage is its ability to combine automated tests with user-friendly test specifications, making it easier for teams to communicate and collaborate on integration tests.

10. Arquillian

Arquillian is a testing platform specifically designed for Java applications running in containers, such as web and app servers. It simplifies the process of integration testing by providing a framework that allows you to test your enterprise applications in a real container environment. Arquillian integrates with various testing frameworks like JUnit, TestNG, and Cucumber, making it easier to perform integration testing in containerized environments. It is particularly useful for testing Java EE and Spring applications.

11. JMock

JMock is a testing framework for Java that helps to mock objects in integration testing scenarios. It is used to simulate the behavior of external services or components that an application integrates with. JMock provides a simple and powerful API for creating mock objects and specifying their expected behavior. It can be used alongside frameworks like JUnit and TestNG for creating unit and integration tests, particularly when testing how an application interacts with external dependencies.

12. Pact

Pact is a contract testing tool used to ensure that the integration between two services or components works as expected. It allows teams to define contracts between services, ensuring that both consumer and provider of an API adhere to the same expectations. Pact is useful for testing microservices, where service dependencies are common. By ensuring that the contract between services is respected, Pact helps detect integration issues early in the development cycle.

13. JBehave

JBehave is a framework for Behavior-Driven Development (BDD) in Java. It enables teams to write and run integration tests in a natural language format, making it easier for non-developers to participate in the testing process. JBehave supports collaborative integration testing for complex systems, particularly in scenarios where the business logic needs to be tested across various components. It integrates with other testing tools like JUnit and TestNG, enabling seamless testing of integration points in applications.

14. Mocha

Mocha is a JavaScript testing framework that is commonly used for testing Node.js applications and services. It supports asynchronous testing and provides features such as test reporting, hooks, and assertions, making it a versatile tool for integration testing. Mocha allows developers to test the integration of various components in a Node.js application, including APIs, databases, and other services. It integrates well with other tools such as Chai for assertions and Sinon for mocking, providing a comprehensive solution for integration testing.

15. TestComplete

TestComplete is a robust automated testing tool that supports web, mobile, and desktop applications. It provides a visual interface for creating tests without requiring code, making it accessible for both technical and non-technical testers. TestComplete supports integration testing by allowing testers to interact with multiple layers of an application, including the UI, APIs, and databases, ensuring that different components work together as expected.

16. SoapUI

SoapUI is a popular tool for testing SOAP and REST APIs. It allows users to create functional and security tests for APIs, making it an essential tool for integration testing of web services. SoapUI allows testers to perform complex queries, validate API responses, and simulate error conditions to test how systems handle various scenarios. It provides support for both manual and automated testing, making it a flexible solution for integration testing.

17. Cypress

Cypress is an end-to-end testing framework designed for testing modern web applications. While it’s known for functional testing, Cypress also excels at integration testing by simulating real user interactions with different components of an application. It provides an interactive environment that makes debugging and test development easier. Cypress supports testing APIs, user interfaces, and databases, and it integrates with CI/CD tools to automate integration tests.

18. Fit Library

The Fit Library is an open-source framework designed to support integration testing through tables that define test data and expected outcomes. It integrates well with Java applications and can be used to create comprehensive integration tests, particularly for testing how various components interact with each other. Fit Library works well with other testing tools like JUnit and TestNG, helping teams automate and streamline integration testing.

19. Selenium Grid

Selenium Grid is a tool that allows for distributed testing of web applications, particularly for integration testing across different environments and browsers. Selenium Grid enables parallel execution of tests, allowing developers to test applications on multiple machines simultaneously. It integrates seamlessly with Selenium WebDriver and is ideal for testing web applications that need to work across different operating systems, browsers, and devices.

20. MicroFocus UFT (Unified Functional Testing)

MicroFocus UFT is an automated testing tool for functional and regression testing, but it also supports integration testing across a wide range of applications. UFT supports a wide variety of technologies, including web, mobile, and enterprise applications. It uses keyword-driven testing and integrates with test management tools, making it ideal for complex integration testing scenarios. UFT’s ability to interact with multiple system components and provide detailed reporting makes it a great choice for enterprise-level integration testing.

21. Katalon Studio

Katalon Studio is an all-in-one test automation platform that supports web, API, mobile, and desktop testing. It is a powerful tool for integration testing, especially for testing web services and APIs. Katalon Studio offers features like recording, scriptless testing, and integrations with tools such as Jenkins and Jira. It provides both manual and automated testing capabilities, making it suitable for teams at different stages of integration testing.

This list covers a broad range of tools for integration testing, each with its own unique features to support different testing scenarios. Let me know if you need any adjustments or additional information for specific tools!

The post Top 21 Tools for Integration Testing Tools in 2026 appeared first on scmGalaxy.

My Application(.ear) is running in Jboss with any issues on 7001 port. There are following requirement as such with me.

Task 1. Integrate Jboss with Apache2 so all the request should be coming from Apache Instead of jboss

Task 2. Implement SSLwith apache2 so it should open with https instead of http.

For task 1, I have followed carefully community.jboss.org/wiki/UsingModjk12WithJBoss with some issues. 1. Application is getting up and running without any issues but logout has some issues. 2. I want to stop JBOSS access point but not getting any clue

For task 2 Once this is up and running, i will have to implement SSL with Apache so it should only get open with HTTPS instead of http. any help on this front as well..any links or Reference.

To follow this issues properly, you can find my work update on this link..I will keep posted the issues…

The post Integration of Jboss and Apache2 and SSL appeared first on scmGalaxy.

The post Integration of CM and CASE Tools appeared first on scmGalaxy.

CM Services in Software Environments: A Question of Integration

There is no concensus regarding where CM services should reside in software environment architectures, despite the diversity of approaches that have been explored. For example, CM services have been offered via:

· Tools such as RCS, SCCS, CCC.
· Operating system extensions at the file-system level such as DSEE and NSE.
· Shared data models such as in the CIS specifications [18] and the PCTE PACT [53] environment.

A further complication is the emergence of a robust CASE tool industry, wherein many popular CASE tools provide their own tool-specific repository and CM services. As a result, CM functions are increasingly provided by, and distributed across, several CASE tools in an environment.
We have found it useful to think of integration in terms of a three-level model. This model, illustrated in Figure 5-1, corresponds to the ANSI/SPARC [48] three-schema  pproach used to describe database architectures. A useful intuition is that this correspondence is more than accidental. The bottom level of integration, called “mechanism” integration, corresponds to the ANSI/SPARC physical schema level. Mechanism integration addresses the implementation aspects of software integration, including, but not limited to: software interfaces provided by the environment infrastructure, e.g., operating system or environment framework interfaces;

software interfaces provided by individual tools in the environment; and architectural aspects of the tools, such as process structure (e.g., client/server) and data management structure (derivers, data dictionary, database). In the case of CM, mechanism integration can refer to integration with CM systems such as SCCS, RCS, CCC and DSEE; and CM implementation aspects such as transparent repositories and other operating-systems level CM services.

The middle level of integration, called “services” integration, corresponds to the ANSI/SPARC logical schema level. Services refers to the high-level functions provided by tools, and integration at this level can be regarded as the specification of how services can be related in a coherent fashion. In the case of CM, these services refer to elements of the spectrum of concepts discussed in chapter 3, e.g., workspaces and transactions, and services integration constitutes a kind of unified model of CM services.

The top level of integration, called “process” integration, corresponds to the ANSI/SPARC external schema (also called “end-user”) level. Process integration can be regarded as a kind of process specification for how software will be developed; this specification can define a view of the process from many perspectives, spanning individual roles through larger organizational pespectives. In the case of CM, process integration refers to policies and procedures for carrying out CM activities.

Integration occurs within each of these levels of integration; thus, mechanisms are inte- 34 ATR grated with mechanisms, services with services, and process elements with process elements. There are also relationships that span the levels. The relationship between the mechanism level and the services level is an implementation relationship: a CM concept in  he services layer may be implemented by different tools in the mechanism level, and conversely, a single mechanism may implement more than one CM concept. The relationship between the services level and the process level is a process adaptation relationship: different CM services may be combined, and tuned, to support different process requirements.

This three-level model provides a working context for understanding integration. For the moment, however, existing integration technology does not match exactly this somewhat idealized model of integration. For example, many services provided by CASE tools (including CM) embed process constraints that should logically be separate, i.e., reside in the process level. Similarly, tool services are often closely coupled to particular implementation techniques.

The level of adaptability required of integrating CM—both in terms of adaptability for projectspecific requirements as well as adaptability to multiple underlying CM
implementations—pushes the limits of available environment integration techniques. The following sections describe the current state of integration technology and its limitations. The next chapter discusses how future generation integration technology can address these shortcomings.

Reference: 
The State of Automated Configuration Management.
A. Brown, S. Dart, P. Feiler, K. Wallnau

The post General SCM Interview Questions appeared first on scmGalaxy.

Hi,

My Application(.ear) is running in Jboss with any issues on 7001 port. There are following requirement as such with me. Task 1. Integrate Jboss with Apache2 so all the request should be coming from Apache Instead of jboss

Task 2. Implement SSLwith apache2 so it should open with https instead of http.

For task 1, I have followed carefully community.jboss.org/wiki/UsingModjk12WithJBoss with some issues. 1. Application is getting up and running without any issues but logout has some issues. 2. I want to stop JBOSS access point but not getting any clue

For task 2 Once this is up and running, i will have to implement SSL with Apache so it should only get open with HTTPS instead of http. any help on this front as well..any links or Reference.

Reagrds, Raj, Build and Release Engineer, scmGalaxy.com

Regards,
Rajesh Kumar
Twitt me @ twitter.com/RajeshKumarIn

rajeshkumar replied the topic: Re:Integration of Jboss and Apache2

Jboss along with Apache 2 setup is working fine but I am getting issues with SSL setup with apache..

I followed the tomcat.apache.org/tomcat-3.3-doc/tomcat-ssl-howto.html
but without success?

Any urgent help?
Regards,
Rajesh Kumar
Twitt me @ twitter.com/RajeshKumarIn

rajeshkumar replied the topic: Re:Integration of Jboss and Apache2

Hi,

With continuation of post, www.scmgalaxy.com/forum/55-jboss/317-int…oss-and-apache2.html

Integration of Jboss with Apache2 which i achieved Successful but got stuck in SSL Setup with Apache2. One point need to be note down is that I am using module_jk.

Any help on this. I could get first page with https URL but once login, its redirecting to http URL.

Any Solution?

my httpd.conf file

My mod-jk.conf file
# Load mod_jk module
# Specify the filename of the mod_jk lib
LoadModule jk_module modules/mod_jk.so
 
# Where to find workers.properties
JkWorkersFile conf/workers.properties
 
# Where to put jk logs
JkLogFile logs/mod_jk.log
 
# Set the jk log level [debug/error/info]
JkLogLevel info
 
# Select the log format
JkLogStampFormat "[%a %b %d %H:%M:%S %Y]"
 
# JkOptions indicates to send SSK KEY SIZE
# Notes: 
# 1) Changed from +ForwardURICompat. 
# 2) For mod_rewrite compatibility, use +ForwardURIProxy (default since 1.2.24)
# See http://tomcat.apache.org/security-jk.html  
JkOptions +ForwardKeySize +ForwardURICompatUnparsed -ForwardDirectories
 
# JkRequestLogFormat
JkRequestLogFormat "%w %V %T"
 
# Mount your applications
JkMount /__application__/* loadbalancer
# Let Apache serve the images
JkUnMount /__application__/images/* loadbalancer
 
# You can use external file for mount points.
# It will be checked for updates each 60 seconds.
# The format of the file is: /url=worker
# /examples/*=loadbalancer
JkMountFile conf/uriworkermap.properties
 
# Add shared memory.
# This directive is present with 1.2.10 and
# later versions of mod_jk, and is needed for
# for load balancing to work properly
## Note: Replaced JkShmFile logs/jk.shm due to SELinux issues. Refer to 
# https://bugzilla.redhat.com/bugzilla/show_bug.cgi?id=225452
JkShmFile run/jk.shm
 
# Add jkstatus for managing runtime data
<Location /jkstatus>
JkMount status
Order deny,allow
Deny from all
Allow from 127.0.0.1
</Location>
 
# Added by Rajesh
#=================================================
<VirtualHost 10.4.51.29:80>
	ServerName 10.4.51.29
	JkMount /elance loadbalancer
	JkMount /elance/* loadbalancer
 
 
 
 
</VirtualHost> 

My httpd-ssl.conf file

Regards,
Rajesh Kumar
Twitt me @ twitter.com/RajeshKumarIn

The post Integration of Jboss and Apache2 appeared first on scmGalaxy.

• Earlier finding & addressing of Bugs – By implementing continuous integration you can do frequent testings which helps to find bugs and error quickly before they ruin your whole efforts later.

• Improve software quality – Early finding issues in the codes, developers can act on them early before they grow into larger problems later,  which ultimately improves the quality of the software.

• Reduce the time it takes to validate – CI immensely reduce the waiting time to find out if your code’s going to work or not.

• Release new software updates – Doing frequently and numbers of time automated build and test of codes helps teams to deliver the new updates to the user more often and faster.

• Open Source
• Easy installation
• Easy configuration
• Rich plugin ecosystem
• Extensibility
• Distributed builds
• Platform: Cross-platform

• Free and Paid
• Gated Commits (prevents developers from breaking sources in a version control system by running the build remotely for local changes prior to commit)
• Build Grid. Allows running multiple builds and tests under different platforms and environments simultaneously
• Integrated code coverage, inspections and duplicates search
• Integration with IDEs: Eclipse, IntelliJ IDEA, Visual Studio
• Platforms supported: Java, .NET and Ruby
• Supports cloud integration

• Open source
• Supports pull request and branch build flow
• Parallel test runs
• Easily synchronize with GitHub
• Flexible plans for every size project
• Platforms: Hosted
• Supports Many Languages like Node js, php, Xcode, python and many more.

• Trial-ware
• Supports many languages like Python, C#, HTML, Java and various others
• Work in any environment like Visual Studio, Xcode, Eclipse, or any Git client
• Extensible tool can work effectively for all shapes and sizes

• Paid and Free trial
• Cross platform
• Allow to Import data from Jenkins
• Works with JIRA and Bitbucket
• Works with others tools like CodeDeply, Ducker, Maven, Git, SVN, Mercurial, Ant, AWS, Amazon S3 buckets
• Support many languages
• Can run multiple builds parerally
• customization of triggers and variables
• Very fast and easy to use

• Licensing plans
• Hosted service
• Server virtualization
• Integrated with middle-ware
• Clear visibility: what is deployed where and who changed what
• Configuration and security differences across environments
• Orchestration of changes across servers, tiers and components
• Automated provisioning, updating, and de-provisioning of cloud environments
• Automated, consistent deployments and rollbacks of applications

• Availability: Free with paid support
• Platform: Windows, Linux, Mac
• Pipeline Concept
• Parallel execution of the tasks
• Support Many languages
• Easily compare builds
• Clearly visualize workflow
• Promote trusted artifacts
• Plugins availability

• Platform: Hosted
• Availability: Free and paid with trial
• Easy to learn
• GitLab CI is fully integrated with GitLab
• Docker support
• Pipeline Concept
• Supports multi-languages – Java, PHP, Ruby, C etc..
• Parallel builds
• Autoscaling
• Build artifacts

• Availability: Free and paid with trial
• Platform: Cross platform
• Supported languages includes Java, Ruby/Rails, Python, Node.js, PHP, Haskell, and Skala
• Supports Docker
• Flexible pricing model

• Availability: Free and paid
• Platform: Hosted
• ParallelCI feature
• Supported languages Go Ruby on Rails, Node.js, PHP, Java, Go, Dart etc..
• Flexible Pricing
• Docker Supported (by upgrading)
• Easy to setup, fast and reliable

The post Top 10 Continuous Integration Tools | List of Best CI Tools | scmGalaxy appeared first on scmGalaxy.

What’s new in Rational Build Forge?

What if your software development organization could vastly accelerate the build and release process?

• Enabling you to manage your development system from virtually anywhere.
• Freeing your developers from the most repetitive, mundane tasks.

What if you could do all this while leveraging your existing investments? That’s where IBM Rational Build Forge software can help.

IBM Rational Automation Framework is a customizable framework that provides automation of environment build-outs, configuration management and application deployments on heterogeneous middleware platforms. Rational Automation Framework helps cut operational costs, improves productivity, and enables you to gain control over complex middleware environments.

• Podcast: All new Rational Automation Framework and Rational Build ForgeThe newest releases of Build Forge and Rational Automation Framework are now available. This podcast provides an overview of the new features and improved functionality of these products. Hear the details from the developers who built them.

Getting started with Rational Build Forge

Rational Build Forge is multifaceted software with many uses, from basic build capabilities to advanced integrations with other IBM and open source software.

With basic-use tutorials, you can begin by creating and running a simple Hello World project, and move on to address more complex features such as environments, dot commands and adaptors. Each of the following tutorials will take about 30 minutes to complete. You can walk through the step-by-step instructions in the tutorial documents while watching the narrated videos.

1. Creating and scheduling a project in Build Forge (Hello World)

• Video
• Tutorial (65KB)

2. Libraries and pass/fail chains

• Video
• Tutorial (113KB)

3. Administration (controlling user access)

• Video
• Tutorial (176KB)

4. Log Filters (with Apache Ant)

• Video
• Tutorial (208KB)

5. Environment Variables

• Video
• Tutorial (414KB)

6. Dot Commands

• Video
• Tutorial (798KB)

7. Agent Update

• Video
• Tutorial (92KB)

Integrating Rational Build Forge across the application life-cycle

Learn how to make Rational Build Forge even more powerful by combining its capabilities with those of other IBM Rational software. With the following resources, you can quickly gain an understanding of the benefits of integration and begin implementing these integrations within your organization.

• Demo: Rational Team Concert/Build ForgeThis demo shows how integration between IBM Rational Build Forge and IBM Rational Team Concert bridges the gap between collaborative lifecycle management and enterprise release engineering. You will learn to:

• Create a Rational Build Forge environment that stores Rational Team Concert connection information.
• Write a Rational Build Forge project that uses the JazzJBE adaptor to integrate with Rational Team Concert source control, and leverages the Rational Team Concert build toolkit Ant tasks to publish rich build results from Rational Build Forge into Rational Team Concert.
• Set up a Rational Build Forge engine and build definition in Rational Team Concert
• Run the Rational Build Forge project from Rational Team Concert.

• Webcast: Build and deploy automation powered by JazzThis webcast provides an overview of the new integration capabilities with IBM Rational Build Forge 7.1.3, IBM Rational Team Concert and IBM Rational Asset Manager. See how these tools work together seamlessly to manage enterprise assets using lifecycle management technologies. The IBM Rational deployment planning and automation solution enables you to execute reliable and repeatable deployments driven by deployment plans. Watch this replay to see the solution in action.
• Article: Integrating Rational Build Forge with Rational ClearCase and Rational ClearQuestThis article explains how to set up and configure these IBM Rational products to work together. It lists the adaptor template samples and identifies the environment variables that need to be added before running the adaptor.
• White paper: Adaptors (291KB)In Rational Build Forge, an adaptor helps with much more than just complex execution flow and decision making. It can also support emailing multiline variables to users, dynamic notification groups, custom BOM additions and project execution control. This white paper details the flexibility and power of adaptors and how to use them effectively.

The post Getting started with Rational Build Forge appeared first on scmGalaxy.

Click Here

scmGalaxy is a community initiatives based on Software configuration management that helps community members to optimize their software development process, Software Development Life Cycle optimization, Agile Methodologies and improve productivity across all aspects of Java development, including Build Scripts, Testing, Issue Tracking, Continuous Integration, Code Quality and more. scmGalaxy group that helps organisations optimize their software development process. We provide consulting, training and mentoring services in Agile Development Practices such as Version Management, Continuous Integration, Build Management, Test-Driven Development, Acceptance-Test Driven Development, Build Automation, Code Quality Practices and Automated Testing.

We provide job oriented training in the area of Configuration management, Build and Release Engineering. Candidates with engineering or software background and looking to either start or change their career to Build and Release Engineering, would benefit most from this training. Instructor-led training course offered in India, Bangalore, Delhi, Pune, Mumbai and Hydrabad. Instructor is an expert in Software configuration management, Build and release engineering with more than 15 years industry experience in india.The Goal of the course make the training attendants equip with all the concepts of build and release engineering.

Contact us

• Mail – info@scmGalaxy.com
• Call – +91 700 483 5930
• WhatsApp – +91 700 483 5930
• Skype – scmGalaxy

Course Objectives
To bring your team up to speed with agile development, We can also run the from Continuous Integration to Continuous Delivery with autoamted course within your premises.

Course Schedule
This course is an intensive 1-day & 2-day workshop with a mixture of teaching and lab exercises. Currently, this course is offered exclusively as an on-site course. Please contact us for more details.

Audience
This is a hands-on, practical course designed to teach specialised skills for real-world development situations. It is thus primarily aimed at a SCM Engineer, Build/Release Engineer and developer audience.

Approach
The course is modular and flexible – depending on specific student needs and requests. Through our trainings, you benefit from the wide experience and architectural expertise of our team. We bring that experience to you in an highly interactive, intensely hands-on setting.

The Working With Continuous Integration training course provides the learning and hands-on experience required to jump start a software development team’s adoption of continuous integration. Using a project-centric blended learning model, the students will examine common testing strategies, learn the fundamental concepts of continuous integration, set up a continuous integration environment, and incorporate continuous integration into their project’s SCM environment.

The Working With Continuous Integration can be delivered using Bamboo, Jenkins, AnthillPro, TeamCity and BuildForge.

If you need help setting up a CI environment, consider extending this course with two days of expert-led consulting.

In the Working With Continuous Integration training course, you’ll learn:

• Introduction to Continuous Integration
• What Is CI?
• Why CI?
• CI Philosophy
• Advantages of CI Within Software Development
• How to Implement CI
• Setting Up a CI Environment
• CI Tools
• Automated Builds
• Automated Tests
• Committing Code
• Creating a Full-featured CI Environment
• Components of a Full-featured Environment
• Requirements of a CI Environment
• Organizational Impact and Buy-in
• Developer Philosophy
• DB Integration
• Automated DB Integration
• Continuous DB Integration
• Continuous Testing
• Automated Unit, Integration, System and Functional Tests
• Writing Tests for Defects
• Integration of Automated Testing With CI
• Continuous Quality
• Code Inspection vs. Code Testing
• Automated Code Analysis
• Code Analysis Tools
• Continuous Deployment
• Philosophy
• Release and Labeling Strategies
• Continuous Improvement
• The Feedback Loop
• The Metrics Loop
• The Improvement Cycle
• Best Practices
• Best of Breed Tools
• Best Practices for Quality Software
• Best Practices for CI
• Rolling Out CI Within Your Organization
• Defining and Measuring Metrics and Reporting
• Defining Proper Metrics
• Measuring and Reporting
• Implementing a Change Strategy to Achieve Desired Metrics

The post Continuous Integration Training | Continuous Integration Course | Trainer | Online | Classroom appeared first on scmGalaxy.

IntelliJ/Ant integration
By Alvin J. Alexander, devdaily.com
The fact that IntelliJ is off-the-shelf ready to work with Ant is a great, great feature. It’s also simple to configure and use.
Assuming that you already know how to use Ant, and you have a build.xml file ready to go, just follow these steps to (a) configure your build script to run from within IntelliJ, and (b) run Ant:

• Assuming you’re in an IntelliJ project, select 6: Ant Build from the slide-in menu bar (“Tool Window Bar”) on the right side of your screen.
• Click the large plus sign icon to add your build.xml file to IntelliJ’s list of known build scripts for this project.
• Navigate the filesystem until you find your build script (i.e., your build.xml file for this project). Select that file.
• To run a desired Ant task, double-click the task name that you want to run. My main task is usually named deploy, so I double-click that.
• Ant should run properly for you, and deploy your application.

It’s really that simple.
The worst problem I’ve run into so far is that when I work on projects on multiple computer systems, my build scripts rely on an environment parameter named ANT_HOST_NAME existing. So, when my build script failed the first time, I said “Oh, dummy Al, you need to set your ANT_HOST_NAME environment parameter. Once I did this and restarted IntelliJ, the Ant build process worked like a champ.
Kudos, dear IntelliJ developers. Great product feature!

Best Example of <Copy>
Type 1:
<copy todir=”${Temp}/uaw/Uaw_compilescripts” overwrite=”true” failonerror=”false”>
<fileset dir=”${SVNCheckout}/scripts/compilescripts” includes=”BuildSh,Compsh,vsamc,buildc.sh,script,compl2,main.sh,makefile,makepl1,script” />
</copy>

Type 2:
<copy todir=”${Temp}/uaw/Uaw_compilescripts” overwrite=”true” failonerror=”false”>
<fileset dir=”${SVNCheckout}/scripts/compilescripts” includes=”BuildSh,Compsh,vsamc,buildc.sh,script,compl2,main.sh,makefile,makepl1,script” />
</copy>

Type 3:
<copy todir=”${Temp}/uaw/Uaw_compilescripts” overwrite=”true” failonerror=”false”>
<fileset dir=”${SVNCheckout}/scripts/compilescripts”>
<include name=”BuildSh”/>
<include name=”Compsh”/>
<include name=”vsamc”/>
</fileset>

</copy>

Type4:
<copy todir=”${Temp}/uaw/Uaw_compilescripts” overwrite=”true” failonerror=”false”>
<fileset dir=”${SVNCheckout}/scripts/compilescripts”>
<includesfile name=”${List}/Uaw_compilescripts_list.txt”/>
</fileset>
</copy>

The post How to run ant build in intellij? – IntelliJ/Ant integration Guide appeared first on scmGalaxy.

Perforce Quick Facts

Clients
==============================================
P4V: Visual Client – (Included in the P4V Installer)
Provides access to versioned files through a graphical interface and also includes tools for merging and visualizing code evolution.
P4Merge: Visual Merge Tool – (Included in the P4V Installer)
Provides graphical three-way merging and side-by-side file comparisons
P4: Command-Line Client – (Included in the Perforce Server Windows Installer)
(Included in the Perforce Server Windows Installer)
P4Web: Web Client – (Included in the P4Web Installer)
Provides convenient access to versioned files through popular web browsers
Server
================================================
P4D: Server – (Included in the Perforce Server Windows Installer)
Stores and manages access to versioned files, tracks user operations and records all activity in a centralized database.
P4P: Proxy Server – (Included in the Perforce Server Windows Installer)
A self-maintaining proxy server that caches versioned files remotely on distributed networks.
Plug-ins & Integrations
=========================================
P4WSAD: Plug-in for Eclipse and WebSphere Studio
Access Perforce from within the Eclipse IDE and the Rational/WebSphere Studio WorkBench family of products
P4SCC: SCC Plug-in – (Included in the P4V Installer)
Enables you to perform Perforce operations from within IDEs that support the Microsoft SCC API including Visual Studio.
P4EXP: Plug-in for Windows Explorer – (Included in the P4V Installer)
Allows Windows users direct access to Perforce.
P4DTG: Defect Tracking Gateway – (Included in the P4DTG Installer)
Allows information to be shared between Perforce’s basic defect tracking system and external defect tracking systems.
P4GT: Plug-in for Graphical Tools
Provides seamless access to version control for files from within Adobe Photoshop, SoftImage XSI, Autodesk’s 3ds max, and Maya
P4OFC: Plug-in for Microsoft Office
Allows documents to be easily stored and managed in Perforce directly from Microsoft Word, Excel, PowerPoint and Project.

Tools & Utilities
=============================================
P4Report: Reporting System
Supports leading tools such as Crystal Reports, Microsoft Access, and Microsoft Excel, or any reporting tool that interfaces with an ODBC data source.
P4Thumb: Thumbnail Generator
Creates thumbnails of graphics files managed by Perforce and stores the thumbnails in the server for presentation in P4V.
P4FTP: FTP Plug-in
Allows FTP clients like Dreamweaver, Netscape, and Internet Explorer to access files in Perforce depots.’
Links to Download: http://www.perforce.com/perforce/downloads/platform.html

The post Perforce Quick Facts – Perforce Quick Start Guide appeared first on scmGalaxy.

SVNAnt
SVNAnt is an Ant task allowing you to interact with Subversion within the convenience of your Ant build script. No more writing custom scripts to get the revision of your repository to tag your release jars. Nor do you have to make command line calls to checkout your latest and greatest as part of your continuous integration process. With SVNAnt, you have the familiarity of the Ant syntax and the flexibility you need for interacting with Subversion.
Features
SVNAnt is a full-featured Subversion client capable of using the native Java bindings or command-line wrappering depending on which is available. Beyond how it works, SVNAnt allows you to do all svn subcommands but the following:

If the svn subcommand is not listed here, you can use it in your Ant build file. Before we continue start using SVNAnt, we have to install it and configure Ant to use it.
Installation
Now that we know what SVNAnt is and what its features are, lets install SVNAnt so that you can begin to use SVNAnt to access Subversion within your Ant build cycle.

Step 1. (Download, Compile and Extract)
This step will download, compile, and “install” the latest version of SVNAnt.
1.1 Using Subversion, checkout the SVNAnt project located here: http://subclipse.tigris.org/svn/subclipse/trunk/svnant
1.2 From the command line, while inside of the location where you checked out SVNAnt to, run “ant makeDistrib”
1.3 Extract the .zip file created in the build directory of your SVNAnt source to a location of your choosing

Step 2. (Modify your build.xml)
The next step is to tell Ant how to find your SVNAnt task by adding the following to your build.xml file:
<path id= “svnant.classpath” >
<fileset dir= “/PATH/TO/YOUR/EXTRACTED/SVNANT-ZIP” >
<include name= “*.jar” />
</fileset>
</path>

<typedef resource=”org/tigris/subversion/svnant/svnantlib.xml” classpathref=”svnant.classpath” />
That should be it. I know that it appears to be too good to be true so lets verify this.

Step 3. (Verify installation)
Building upon Step 2, lets create a new ant task that will use the wcVersion feature of SVNAnt to get some information about your repository from a local working copy:
<target name=”testSVNAnt”>
<svn>
<wcVersion path= “PATH/TO/YOUR/WORKINGCOPY” />
</svn>

<echo message= “Subversion repository url: ${repository.url}” />
</target>
(Note: In the event that you need to pass credentials to Subversion, look here.)
The output should be something similar to this:
$ ant testSVNAnt

Buildfile: build.xml

testSVNAnt:
[svn] <WcVersion> started …
[svn]  finished.
[echo] Subversion repository url: http://svn.apache.org/repos/asf/incubator/openejb/trunk

BUILD SUCCESSFUL
Total time: 43 seconds

Pat yourself on the back. You have successfully installed SVNAnt and you are ready to implement Subversion into your Ant build cycle. Instead of us going through each available feature for SVNAnt, please view the SVNAnt Documentation. Now lets talk about why you may want to use SVNAnt to allow for Subversion interaction inside of your Ant build cycle.

The post How to Integrate Subversion Into Your Ant Build ? – Step by step guide appeared first on scmGalaxy.

With Visual Studio 2010 RC released recently, we jumped on the release and began to code with VS2010.  One issue that popped up was that now all builds were targeting MSBuild 4.0.

That doesn’t seem to be a big problem until our CruiseControl CI server kicked in, downloaded our updated code and failed building the upgraded projects.

Fortunately there is a very quick solution to this little problem.  There are a couple of requirements.

1. You need to have VS2010 RC installed somewhere
2. You need to download the .Net Framework 4.0 (I recommend the full version and not just the Client Profile, it ensures you don’t miss anything)

To fix, do the following:

1. download and install the .Net Framework 4.0 on the CI server (then restart the server)
2. on the computer where VS2010 RC is installed go to the following path:
%programfiles%\MSBuild\Microsoft\VisualStudio
3. copy the v10.0 folder located in that directory into the CI server at the same path (or wherever our MSbuild path is on the CI server)
4. Once that is done, edit the ccnet.config file at the tag and change it to the new .Net 4.0 Framework installed (you should only need to change the section “\v3.5\” to “\v4.0.xxxxx\”

Hope this helps

The post Running MSBuild 4.0 and MSBuild 3.5 on Continuous Integration appeared first on scmGalaxy.

Bamboo – A Continues Integration Server

Continuous integration (CI) brings faster feedback to your development process, preventing bugs from piling up and reducing the risk of project delays.

Bamboo enables development teams of any size to adopt CI in minutes, easily integrate it with their work day and scale their build farm using elastic resources in the Amazon EC2 cloud.

Continuous integration (CI) brings faster feedback to your development process, preventing bugs from piling up and reducing the risk of project delays.

Bamboo enables development teams of any size to adopt CI in minutes, easily integrate it with their work day and scale their build farm using elastic resources in the Amazon EC2 cloud.

Bamboo makes every stage of continuous integration adoption easy, intuitive and pain-free.

Set up your first CI build in minutes
Integrate/ Collaboration CI with your current tools and workflow
Scale your build farm on-premises or in the cloud!
Analyse and improve your build performance
Extend Bamboo with plugins and the REST API
Full feature list and system requirements

Integrate/ Collaboration

Bamboo lets you pick how and when you’re notified about builds and integrates easily with tools you’re already using, so your team will be able to work together to keep your builds green!

Notifications via email, RSS, IM or IDE pop-up:
With Bamboo each team member can choose how and when to be notified:

Email, RSS, IM or IDE pop-up notifications
Customised email templates (HTML or plain-text)

Choose which builds to be notified about:

All builds for a project
Specific build plans
Every time a build finishes, only when it fails X times, only when it hangs, or only when it times out

Priorities your build queue
When your build agents are busy, Bamboo builds go into a queue.

Need to see the results of a build ASAP? You can:

Escalate builds to the front of the queue with one click.
Stop in-progress builds.
Move lower-priority builds to the back of the line.

Apply labels and comments to build results
Why did a build fail? What did you fix to turn it green again? Which builds have been tested by your QA team? What builds are approved for release to customers? Bamboo let’s you provide content to your builds results using labels and comments.

• Apply labels and comments via your Web browser, IDE, or Bamboo’s unique 2-way IM system
• Subscribe to an RSS feed of all build results with certain labels (e.g. “QA_FAILED”, “PATCH”,etc.)

Run and fix builds from Eclipse and IntelliJ
Bamboo integrates with Eclipse and IntelliJ IDEA to bring build management and notification into the IDE:

• Run, label and comment builds
• Receive pop-up notifications for builds you care about
• Quickly identify failing tests and re-run them locally with just one click

Link builds to JIRA issues
Bamboo integrates with JIRA and allows you to easily:

• View all builds related to an issue
• View all issues related to a build, and mark them resolved
• Embed build status and summary gadgets into your JIRA project dashboards

View changes that triggered builds with FishEye
By integrating Bamboo with FishEye, you can quickly see what files were changed to trigger a build and what JIRA issue the changes were made for. Want to see exactly what changed? FishEye diffs are just a click away!

Run Clover Test Optimization and code coverage
Integrate Clover for Java Test Optimization and code coverage, and you’ll instantly get faster builds and better code quality insights!

• Clover Test Optimization can make your Java unit and functional tests run several times faster
• View method, branch and statement coverage
• See when and where coverage drops over time

Display results in Confluence dashboard portlets
Bamboo provides portlets that can easily be embedded on any Confluence page, so you can keep every project stakeholder up to date on project status.

• See pass/fail status, duration, and number of failed tests for recent runs of a build plan.
• View the latest status for all builds in a project.

Embed JavaScript widgets in any HTML page
Bamboo provides JavaScript widgets that can be embedded into any HTML page. With just a few lines of code, create custom pages that include:

• Latest build results
• Latest changes
• Last result of all builds in a project
• Plan summary graphs

Scale Your Build System

As your team runs more and more CI builds, you’ll want to add more computing power to maintain fast feedback on your build and test results.

Bamboo makes scaling your build system a snap with:

• Remote agents that run on-premises
• Elastic agents in the Amazon EC2 cloud.

Remote agents

Your Bamboo server can manage dozens of remote agents simultaneously, taking advantage of available computing power to provide the fastest feedback possible. With remote agents you can:

• Run multiple builds at once to reduce feedback times
• Test on different platform configurations

Elastic agents

Elastic agents are remote agents that run in the Amazon Elastic Compute Cloud (EC2). By using the cloud, you can instantly scale your build environment as your development cycles ebb and flow and build queues become longer. Bamboo makes it easy to customize and manage your elastic agents:

• Schedule agents to start and stop based on known peaks and valleys in your need for CI builds.
• Cut operational costs by taking advantage of EC2’s reserved instance pricing and availability zones.
• Customise agent images with different operating systems, installed software, and computing power to create the most flexible building and testing system possible.
• Reduce data transfer and startup times by using Amazon Elastic Block Storage (EBS) for persistence.

Every build agent (remote or local) has specific capabilities that are used to match the requirements of queued builds.

Bamboo’s web interface makes it easy to manage all your agents and view a log of recent activity for each agent.

Analyse and Improve Your Builds

Your team is running builds on every commit, comprehensive performance and functional tests are running every night, and your build farm has been scaled out. Wondering where and how you can make improvements? Bamboo makes it easy to see the performance of your builds and identify trouble spots and possible improvements.

• Find out why a build failed
• View build plan performance across time
• See what’s breaking most so you can investigate
• Compare several plans
• Compare team performance and drill into author details

What happened?
When your builds turn red, you want to fix them as fast as possible! Bamboo provides information to your team that makes root-cause analysis easier, so you can turn the build green again ASAP.

• Full stack traces for compilation failures
• Full stack traces for test failures
• Highlighting of newly failed tests
• Click-through to the failing code from within the IDE

Build plan summaries at a glance
Bamboo’s plan summary view presents a wealth of information about each build plan including:

• Results of the latest build
• Historical pass percentage and average build time
• Result, duration, and number of failed tests for recent builds
• Duration and failure trends across time

Find your trouble spots
Bamboo identifies problem areas within each build based on its performance history including:

• Most common failures
• Tests that take longest to fix
• Long-running tests

Compare your build plans
Which builds are turning red the most often? Which builds are taking longest to run? Bamboo reports provide useful information within a few clicks, for the exact set of plans you care about. Reports include:

• Success percentage
• Duration
• Activity
• of tests
• of failed tests
• Time to fix failures
• Clover code coverage

View the CI scorecard
Who’s submitting bullet-proof code? Who’s going to buy beer for breaking the most builds? Bamboo provides insightful reports for:

• Full Teams: # of builds triggered / failed / fixed
• Individuals: build history, last 10 triggered / failed / fixed
• Groups: Success percentage, # of failed / fixed builds

Extend Bamboo

Bamboo works great right out of the box, and it can be extended to fit your exact needs:

• Install 3rd party plugins from the Atlassian Plugin Exchange to add support for additional SCMs, test tools and more.
• Create your own Bamboo plugins. Get help from Atlassian and other Bamboo developers in the Bamboo Development Forum and then share your plugins on the Atlassian Plugin Exchange
• Use Bamboo’s comprehensive REST API to integrate Bamboo with other tools or automate common tasks.

System requirements and supported development tools

Build and agent management

Build result notifications

External tool integrations

Elastic Bamboo

Build analysis and reporting

Security and user management

Extending Bamboo

Reference:

Features:
http://www.atlassian.com/software/bamboo/features/
Bamboo: getting Started
http://confluence.atlassian.com/display/BAMBOO/Bamboo+101
Forum
http://forums.atlassian.com
Plugins
https://plugins.atlassian.com/search/by/bamboo
http://confluence.atlassian.com/display/BAMBOO/Bamboo+Plugin+Guide
Jira and Bamboo
http://www.atlassian.com/better-together/progress_report.jsp

The post Bamboo – A Continuous Integration Server – Complete Guide appeared first on scmGalaxy.

As I have mentioned in a previous blog entry, I have come to love using ANT in my development environment. One of the things that I like about it is how well it integrates with my Subversion repository using SVNAnt. If you are not using either ANT or Subversion, you owe it to yourself and your team to check it out.

Here we’ll go over a simple build script that exports application files from the Subversion repository into a local folder in the CFEclipse project. You can then view the following entry on how to ftp that into your production/staging server.
First we need to make sure that your ANT install has the necessary SVNAnt jar files. You can download them here: http://subclipse.tigris.org/svnant.html. Once you unpack the svnant-1.0.0.zip file, you’ll find three jar files: svnant.jar, svnClientAdapter.jar, svnjavahl.jar. Place them on your
[ANTInstall]/lib* folder.

Once you have the jar files in place, you can define them in your build file’s property section like so:
<!– svnant lib –>
<property name=”svnant.lib” value=”lib” />
<property name=”svnant.jar” value=”${svnant.lib}/svnant.jar” />
<property name=”svnClientAdapter.jar” value=”${svnant.lib}/svnClientAdapter.jar” />
<property name=”svnjavahl.jar” value=”${svnant.lib}/svnjavahl.jar” />
Followed by this path definition after all your properties have been defined:

<!– path to the svnant libraries. Usually they will be located in ANT_HOME/lib –>
<path id=”project.classpath”>
<pathelement location=”${svnjavahl.jar}” />
<pathelement location=”${svnant.jar}” />
<pathelement location=”${svnClientAdapter.jar}” />
</path>

Now all you have left to do is add the following task definition:
<!– load the svn task –>
<taskdef resource=”svntask.properties” classpathref=”project.classpath”/>

Now you are all set! You can now call tasks like the following export target:

<!– define properties –>
<!– svn repo url –>
<property name=”svn.url” value=”http://[mysvnhost]/svn/repo/myprojectFiles/” />
<property name=”svn.exportPath” value=”[yourDirectory]:\\[pathToYourCFEclipseProject\\build” />

<target name=”svn.export”>
<echo message=”Exporting application files from svn repository:” />
<input message=”Please enter svn repo username:” addproperty=”svn.username” />
<input message=”Please enter svn repo password:” addproperty=”svn.password” />
<mkdir dir=”${svn.destPath}” />
<svn username=”${svn.username}” password=”${svn.password}”>
<export srcUrl=”${svn.url}” destPath=”${svn.exportPath}” revision=”HEAD” />
</svn>
<echo message=” … finished exporting files.” />
</target>

That’s it. No more running command line tasks to get your subversion commands. For additional info and other SVN tasks you can go to http://subclipse.tigris.org/svnant/svn.html

The post ANT Builds and Subversion (SVN) | Ant integration with Subversion guide appeared first on scmGalaxy.

This post is about using ANT to perform some of the most common source-control related tasks such as export, tagging, and branching. I am using ANT version 1.7.0 and SVN Ant version 1.1-rc3, bound against Subversion 1.4.0.

The related software can be downloaded here:
1.    SVN Ant = http://subclipse.tigris.org/svnant.html
2.    ANT = http://ant.apache.org/
I shall start with build.properties, which lists a few key/value pairs used in our SVN Ant task build file, referred as svn-tasks.xml:

Content of build.properties:
####START of SVN Properties ####
svn.repository.url=http://xyz.com/repos/somereponame
svn.project.base.path=someprojectname
svn.username=user name to access repo
svn.password=password to access repo
#This shall be name of the tag,
#This property should always be updated before build starts
#This property shall be used to export
tag.name=SOME_TAG_NAME_12222008
#This shall be name of new branch,
#this property should be used only when new branch is to be created
new.branch.name=NEW_BRANCH_12222008
####END of SVN Properties ####
Content of svn-tasks.xml:
<property file=”build.properties”></property>

<!– SVN and SVN-ANT Tasks properties –>
<property name=”svn.repository.url” value=”${svn.repository.url}”/>
<property name=”svn.project.base.path” value=”${svn.project.base.path}” />
<property name=”svn.base.url” value=”${svn.repository.url}/${svn.project.base.path}”/>
<property name=”svnant.lib.dir” location=”svn-ant-lib”/>
<property name=”svnant.javahl” value=”false” />
<property name=”svnant.svnkit” value=”true” />
<!– SVN and SVN-ANT Tasks properties –>

<!– *************************************************************** –>
<!–   Set-Up of SVN-ANT classpath                                   –>
<!– *************************************************************** –>
<path id=”svnant.classpath”>
<fileset dir=”${svnant.lib.dir}”>
<include name=”**/*.jar” />
</fileset>
</path>

<!– *************************************************************** –>
<!–   Loading of SVN task                                           –>
<!– *************************************************************** –>
<typedef resource=”org/tigris/subversion/svnant/svnantlib.xml” classpathref=”svnant.classpath” />

<!– *************************************************************** –>
<!– tool-availability: Determine if SVN-ANT is available.           –>
<!– *************************************************************** –>
<target name=”tool-availability”>
<available resource=”org/tigris/subversion/svnant/svnantlib.xml”
classpathref=”svnant.classpath”
property=”available.svnant”
/>
<echo message=”SVN-ANT is available = ${available.svnant}”/>
</target>

<!– **************************************************************** –>
<!– does-svnant-exist: depends on tool-availablility and     –>
<!–                    displays error message                                   –>
<!– ***************************************************************** –>
<target name=”does-svnant-exist” depends=”tool-availability”>
<fail unless=”available.svnant”>
SVN-ANT is not available, cannot perform tagging or checkout/export svn ant task.
</fail>
</target>

<!– ****************************************************************** –>
<!– svntag: performs tagging using properties from                              –>
<!–         build.properties and uses SVNANT tasks                              –>
<!– ******************************************************************* –>
<target name=”svntag” description=”tags individual project using svnant task”>
<property name=”svn.tag.message” value=”Tagging Project ${project.name} with tag name ${tag.name} from trunk “/>
<property name=”src.url”  value=”${svn.base.url}/${project.name}/trunk/”/>
<property name=”dest.url” value=”${svn.base.url}/${project.name}/tags/${tag.name}”/>

<echo message=”${svn.tag.message}”/>
<echo message=”${src.url}”/>
<echo message=”${dest.url}”/>

<svn javahl=”${svnant.javahl}” svnkit=”${svnant.svnkit}” username=”${svn.username}” password=”${svn.password}”>
<copy srcUrl=”${src.url}” destUrl=”${dest.url}” message=”${svn.tag.message}”/>
</svn>
</target>

<!– ****************************************************************** –>
<!– svnexport: performs export using properties from                            –>
<!–            build.properties and uses SVNANT tasks                           –>
<!– ****************************************************************** –>
<target name=”svnexport” description=”exports individual project using svnant task”>
<property name=”svn.tag.message” value=”Exporting Project ${project.name} with tag name ${tag.name}”/>
<property name=”src.url”  value=”${svn.base.url}/${project.name}/tags/${tag.name}”/>
<property name=”destPath” value=”${dest.path}”/>
<echo message=”${svn.tag.message}”/>
<svn javahl=”${svnant.javahl}” svnkit=”${svnant.svnkit}” username=”${svn.username}” password=”${svn.password}”>
<export srcUrl=”${src.url}” destPath=”${destPath}/${project.name}”/>
</svn>
</target>

<!– ****************************************************************** –>
<!– svnbranch: creates a new branch using properties from                       –>
<!–            build.properties and uses SVNANT tasks                           –>
<!– ****************************************************************** –>
<target name=”svnbranch” description=”creates a new branch for individual project using svnant task”>

<property name=”svn.branch.message” value=”Creating new branch for
Project ${project.name} with new branch name ${new.branch.name} from
trunk”/>
<property name=”src.url”  value=”${svn.base.url}/${project.name}/trunk/”/>
<property name=”dest.url” value=”${svn.base.url}/${project.name}/branches/${new.branch.name}”/>

<echo message=”${svn.branch.message}”/>
<echo message=”${src.url}”/>
<echo message=”${dest.url}”/>

<svn javahl=”${svnant.javahl}” svnkit=”${svnant.svnkit}”
username=”${svn.username}” password=”${svn.password}”>
<copy srcUrl=”${src.url}” destUrl=”${dest.url}” message=”${svn.branch.message}”/>
</svn>
</target>

Link: http://java.dzone.com/articles/how-use-svn-tasks-with-ant

The post How to Use SVN Tasks with ANT ? appeared first on scmGalaxy.