Matthew Doar B. - Practical JIRA Plugins
Here you can read online Matthew Doar B. - Practical JIRA Plugins full text of the book (entire story) in english for free. Download pdf and epub, get meaning, cover and reviews about this ebook. year: 2011, publisher: OReilly Media, genre: Computer. Description of the work, (preface) as well as reviews are available. Best literature library LitArk.com created for fans of good reading and offers a wide selection of genres:
Romance novel
Science fiction
Adventure
Detective
Science
History
Home and family
Prose
Art
Politics
Computer
Non-fiction
Religion
Business
Children
Humor
Choose a favorite category and find really read worthwhile books. Enjoy immersion in the world of imagination, feel the emotions of the characters or learn something new for yourself, make an fascinating discovery.
- Book:Practical JIRA Plugins
- Author:
- Publisher:OReilly Media
- Genre:
- Year:2011
- Rating:3 / 5
- Favourites:Add to favourites
- Your mark:
Practical JIRA Plugins: summary, description and annotation
We offer to read an annotation, description, summary or preface (depends on what the author of the book "Practical JIRA Plugins" wrote himself). If you haven't found the necessary information about the book — write in the comments, we will try to find it.
- Use Jiras Plugin Sdk, and learn several aspects common to all plugins
- Create your own custom field type, using a Jira plugin
- Delve into advanced aspects of custom field plugins, and discover how searching for values in custom fields works
- Create Jira plugins to use with workflows, and learn about conditions, validators, and post-functions
- Store data using the PropertySet interface and the Active Objects plugin
- Upgrade a plugin and upload it to Atlassian Plugin Exchange (Pac)
Matthew Doar B.: author's other books
Who wrote Practical JIRA Plugins? Find out the surname, the name of the author of the book and a list of all author's works by series.
Practical JIRA Plugins — read online for free the complete book (whole text) full work
Below is the text of the book, divided by pages. System saving the place of the last page read, allows you to conveniently read the book "Practical JIRA Plugins" online for free, without having to search again every time where you left off. Put a bookmark, and you can go to the page where you finished reading at any time.
Font size:
Interval:
Bookmark:
Matt Doar runs Consulting Toolsmiths, a software consultancy inSilicon Valley and has extensive experience configuring andcustomizing JIRA for clients all over the world. He is an Atlassianpartner and is part of the wider Atlassian development community.
He also wrote "Practical Development Environments", O'Reilly (2005)which described the basics of software tools - version control, buildtools, testing, issue trackers, automation.
Matt also runs the blog http://jiradev.blogspot.com which has a number of similar tips, trick and examples for practical JIRA development.
Building any plugin for JIRA starts with downloading the most recent Atlassian Plugin SDK (Software Development Kit) from the Atlassian Developer Network at . Subsequent chapters contain details about specific kinds of JIRA plugins.
The JIRA Developer Forum at http://forums.atlassian.com/forum.jspa?forumID=100 is a useful place to find answers to your questions after youve started using the SDK. The Forum is now read-only, but similar technical discussions continue at https://answers.atlassian.com/tags/jira-development.
Beyond some basic Java skills, in order to write a JIRA plugin youll also need to understand how Apache Velocity templates are used by JIRA. These are the files that control how HTML pages are formatted, and are covered in more detail in .
JIRA uses many other technologies and it can be useful to have some familiarity with any of these: Subversion, Mercurial, Ant, Apache JSP, JavaScript, JQuery and Jersey for REST. However for most plugins you wont need to know anything about themjust Java and a bit of Velocity and Maven.
[] This SDK is not the same as the JIRA Plugin Development Kit , which was used for JIRA 3.x plugins.
JIRA plugins use an Apache Maven 2 project for each plugin to produce a Java .jar file that can be installed in JIRA.
A Maven project has a fairly rigid layout, always with a top-level XML file named pom.xml made up of the plugins name, version, dependencies and so on. The groupId and artifactId variables in pom.xml are what make a plugin unique within Maven. The artifactId is also what will appear as part of your plugin .jar files name. The name variable is the more verbose name of the plugin, as seen in the JIRA plugin administration pages. The SDK will create a working pom.xml file for us with some reasonable default values.
Atlassians guidelines on the use of JIRA are that a name such as Acme plugin for JIRA is okay, whereas JIRA plugin for Acme is not. The former connotes a 3rd party plugin for JIRA, while the latter connotes an Atlassian-developed tool. If in doubt, contact developer-relations@atlassian.com .
The first thing to do is to unpack the SDK in a convenient location. This location is referred to as $SDK_HOME in the examples below. You can then create a JIRA plugin with a single command:
This command will prompt you for a few values and then create a new plugin directory with enough files to build a plugin. This skeleton plugin does nothing, but it can be installed in JIRA and will appear in the list of plugins shown in the Administration plugins page.
As mentioned earlier, the artifactId and groupId values appear directly in the Maven pom.xml file. Every Atlassian plugin has a unique identifier named key . The key for each plugin is defined in the file atlassian-plugin.xml, and by default the key is artifactId.groupId .
The version argument is the version of your plugin, not the JIRA version. Versions can be any text but the Atlassian Plugin Exchange (see the section ) now requires that the version starts with three digits, not two. A version can also look like 4.2.0-alpha. The package argument is the name of the Java package that the plugins Java source code will use.
If you want to, you can also provide the same information that was required to create a plugin directly from the command line:
$SDK_HOME/bin/atlas-create-jira-plugin \ --artifactId myplugin \ --groupId com.mycompany.jira.plugins \ --version 4.2.0 \ --package com.mycompany.jira.plugins.myplugin --non-interactiveThe most important files in a plugin directory and their purposes are as follows.
The top-level Maven 2 project file for the plugin.
READMEThe place to start for the description of what the plugin is intended to do.
LICENSEA place holder for the license for the plugin. Many JIRA plugins use the BSD license by default, but the section has more information about choosing a license.
srcThe directory that contains all the source files needed to build the plugin.
src/main/resources/atlassian-plugin.xmlThe XML file that specifies exactly what the plugin really contains. The order of the elements in this file doesnt make a difference to how they work.
src/main/java/com/mycompany/jira/plugins/mypluginThe default location for Java source files, based on the package name used when the plugin was created.
A sample Java source file, automatically generated. You can rename or delete this file later on.
targetThe location of all generated files after a build has finished. None of the files in this directory need to be version controlled.
target/myplugin-4.2.0.jarThe generated plugin package that is deployed to JIRA to actually use the plugin.
There are a few other files generated in the src/test directory related to testing your plugin. You can delete them if theyre not wanted, but an even better practice is to write some tests as described at http://confluence.atlassian.com/display/DEVNET/Plugin+Testing+Resources+and+Discussion.
Before diving into building a plugin, its useful to know how to understand what any JIRA plugin does. Knowing how to read a plugin also makes it easier to find examples on which to base your own work.
My own approach is to start with the top-level Maven file pom.xml and to look for the jira.version element. That should tell you which version of JIRA the plugin was last built against. If its too old for you to use, then see for ideas on how to update it. There is also a jira.data.version element that tells you the version of the JIRA database schema the plugin last worked with. As might be expected, this changes less frequently than jira.version.
The next file to read is src/main/resources/atlassian-plugin.xml. This file contains all the different plugin module types that are used in the plugin and tells you what the plugin provides; e.g., a new custom field type. The initial skeleton plugin doesnt have any plugin modules in this file because it doesnt do anything.
Then Ill read any documentation or perhaps look at a few screen shots. Usually only after all that do I look at actual Java source code and Velocity template files.
The minimal commands to build a plugin from the command line are:
$ cd myplugin$ $SDK_HOME/bin/atlas-package...[INFO] ----------------------------------------------------[INFO] BUILD SUCCESSFUL[INFO] ----------------------------------------------------[INFO] Total time: 26 seconds[INFO] Finished at: Wed May 11 03:11:48 PDT 2011[INFO] Final Memory: 56M/118M[INFO] ----------------------------------------------------Font size:
Interval:
Bookmark:
Similar books «Practical JIRA Plugins»
Look at similar books to Practical JIRA Plugins. We have selected literature similar in name and meaning in the hope of providing readers with more options to find new, interesting, not yet read works.
Discussion, reviews of the book Practical JIRA Plugins and just readers' own opinions. Leave your comments, write what you think about the work, its meaning or the main characters. Specify what exactly you liked and what you didn't like, and why you think so.