Release Day! 2.5.18, 3.0.9 and I'm Very Pleased to Announce: 4.0.0!
Posted by Megan Chinburg Oct 30, 2009
Attention, Developers!
Have you ever wondered how you can run an upgrade task in a plugin to do something like add an extra column to a table or a new index to boost performance? You know, those one-time tasks that need to be applied consistently across all your environments? One of the powerful (yet often overlooked) features in Jive SBS 3.0 is the ability to run upgrade tasks in a plugin. These tasks are run once and can do anything from modifying a database to creating new files and folders.
The Past...
Prior to SBS, developers relied on a number of techniques to perform upgrade tasks, including:
- Checking for the presence of a system property and, if not present, firing off a background thread to perform the upgrade task from the plugin class' init() method
(downside: someone deletes the system property and your upgrade task gets run again, clustering introduces risk that your upgrade will be run more than once, more work than necessary) - Writing a SQL script that could be run by the DBA on each environment prior to the plugin upgrade
(downside: may require special permission to run scripts, especially in hosted environment; not cross-platform compatible; multiple steps in deployment process may easily be forgotten) - Overlaying the core application to include upgrade tasks with core application upgrade tasks to take advantage of native process for handling upgrades
(downside: must be merged with every release, requires multiple deployment artifacts, risky)
...And Now?
I hoped you would ask! Here's what you need to do:
Step 1
If you don't already have it, add the following two items to your plugin.xml:
<plugin>
<!--...omitted for clarity...-->
<databaseKey>pluginName</databaseKey>
<databaseVersion>1000001</databaseVersion>
<!--...omitted for clarity...-->
</plugin>
Now when the plugin is installed, it will create a record in the jiveVersion database table with the appropriate values for name and version.
Step 2
Create a new file "upgrade.xml" at the root of your plugin. This new file will live alongside your spring.xml, struts.xml, etc., and contains the list of upgrade tasks that will be run. Each upgrade task is given a version. If the version of your upgrade task is greater than the value in the jiveVersion table for your plugin, your task will be run. Once the upgrade is complete, the version in the database will be the same as the highest upgrade task version. Here's an example upgrade.xml taken from our Supportal:
<upgrade-config>
<upgrades>
<upgrade order="1">
<name>supportal</name>
<tasks>
<!-- 3.2.0 -->
<task version="32000001"
className="com.jivesoftware.community.upgrade.tasks.AddEnvironmentsTask"/>
<task version="32000002"
className="com.jivesoftware.community.upgrade.tasks.EnvironmentPermissionsTask"/>
<!-- 3.2.1 -->
<task version="32100001"
className="com.jivesoftware.community.upgrade.tasks.DeleteDuplicateEnvironmentFieldValuesTask"/>
<!-- 3.2.2 -->
<task version="32200001"
className="com.jivesoftware.community.upgrade.tasks.RemoveWebServerRequirementFromEnvironmentsTask"/>
<!-- 3.2.3 -->
<task version="32300001"
className="com.jivesoftware.community.upgrade.tasks.UpdateEnvironmentFieldOptionsTask1"/>
</tasks>
</upgrade>
</upgrades>
</upgrade-config>
Once you have added your task, make sure to update the databaseVersion in your plugin.xml to the same value as your highest upgrade task!
Step 3
Create your upgrade task class. In the example below we're calling out to an XML file that contains the new schema details. More on that in a sec. Here's the source code:
package com.jivesoftware.community.upgrade.tasks;
...imports omitted
public class RemoveWebServerRequirementFromEnvironmentsTask implements UpgradeTask {
private static final String SQL = "RemoveWebServerRequirementFromEnvironmentsTask";
public String getName() {
return "Remove requirement for filling out web server from environment template fields";
}
public String getDescription() {
return "Task to mark environment template fields for web server as non-required.";
}
public String getEstimatedRunTime() {
return "1 second";
}
public String getInstructions() {
return "To run manually, copy the SQL from the RemoveWebServerRequirementFromEnvironmentsTask.xml and run directly against your DB.";
}
public boolean isBackgroundTask() {
return false;
}
public void doTask() throws Exception {
UpgradeUtils.executeSQLGenFile(SQL, getClass());
}
}
Step 4 (almost there!)
The last thing you need to do (assuming you are updating your DB, of course) is to create the XML file that will be read when UpgradeUtils.executeSQLGenFile(SQL, getClass()) is called. To do this create an XML file in the same path of your class with the same name as your class, only ending with the .xml extension. Following the example above, this could look like the following:
<schema name="Environment Schema">
<sql description="Update default data for environments."><![CDATA[
update supenvtemplfield set isRequired = 0 where envtemplfieldid = 40;
update supenvtemplfield set isRequired = 0 where envtemplfieldid = 59;
update supenvtemplfield set isRequired = 0 where envtemplfieldid = 78;
update supenvtemplfield set isRequired = 0 where envtemplfieldid = 97;
update supenvtemplfield set isRequired = 0 where envtemplfieldid = 116;
update supenvtemplfield set isRequired = 0 where envtemplfieldid = 135;
update supenvtemplfield set isRequired = 0 where envtemplfieldid = 154;
]]>
</sql>
</schema>
The <sql> element lets you execute arbitrary DML or DDL statements against your DB. You can also use the <alter> tag to change an existing table:
<alter table="jiveBlog" type="add" description="Add Container Type and ID to JiveBlog">
<column name="containerType" type="int" nullable="false" default="-2"
description="The type of the container to which the blog belongs"/>
<column name="containerID" type="bigint" nullable="false" default="17"
description="The ID of the container to which the blog belongs."/>
<index type="normal" name="jiveBlg_ctID_idx" column="containerID, containerType"/>
</alter>
Additionally, you can define new tables using the same syntax as you would in your schema.xml:
<table name="environmentTemplate" description="Customer environment template">
<column name="templateID" type="bigint" nullable="false" description="Environment template ID."/>
<column name="name" type="varchar" size="255" nullable="false" unicode="true"
description="The display name of the template (shows in environment template selection)."/>
<column name="description" type="text" nullable="true" index_none="true" unicode="true"
description="Tells admins the purpose of this template"/>
<column name="status" type="int" nullable="false"
description="The published status of the environment template."/>
<index type="primary" name="envTempl_pk" column="templateID"/>
<index type="normal" name="envTempl_templID_st_idx" column="templateID,status"/>
</table>
What happens if my upgrade runs into problems?
It is important to note that plugin upgrades are run in the background during plugin initialization, so you won't see the upgrade screen similar to what is shown when you upgrade SBS. However, any errors that occur during the plugin installation will be reported to you in the admin console under System > Plugins. Here's what you can expect to see:
Questions?
Leave a comment for me here, or shoot a message to @austrum on Twitter!
How to be productive using the Supportal ( As a Support Engineer )
Posted by Sean Moran Aug 12, 2009The Supportal provides a unique set of tools for communicating with a large audience and driving the resolution of an issue. Tools such as links, in-line images, macros, and attachments make it easy to share information.
Links
While links are a simple concept, they are also extremely useful. I often use links to direct readers to web pages of interest such as documentation or bug reports for third-party libraries.
One example is SBS installation and configuring additional options. I could send someone a link to the Jive SBS Installation Documentation, as well as the Operations Cookbook. These links make it easy to bring external resources to people's attention with minimal effort.
Following links when reading online content is probably second nature to most users, so it seems only fitting that we use the same tools as in the rest of the web.
In-Line Images
A picture is worth a thousand words. Using in-line images can help easily illustrate a point or issue you're seeing. Images can avoid unnecessary back and forth when trying to troubleshoot.
For example: I need to explain where to enter your database URL. Instead of describing what the screen might look like and where you can test your settings, I could just add the following image to a case:
With this image, I can just add a few instructions:
- Enter your Database URL in this box
- Test your connection with this button
Macros
One important aspect of effective communication is formatting. Macros provide easy ways to format Java, SQL, XML, and plain old text. You can even quote the original message and add your reply in-line.
Lets have a look at a few examples:
package com.jivesoftware.base
/**
* Dummy Class
*/
public class Dummy {
public static void main(String[] args) {
System.out.println("Macros look fantastic!")
}
}
vs.
package com.jivesoftware.base;
/**
* Dummy Class
*/
public class Dummy {
public static void main(String[] args) {
System.out.println("Macros look fantastic!")
}
}
SELECT * FROM jiveUser;
vs.
SELECT * FROM jiveUser;
While you can read both versions of the above examples, the macros make it even easier to read the posted code, as macros provide syntax highlighting and a backdrop to let you know you're looking at a snippet of code.
Attachments
It's often necessary to share documents and log files, and attachments make it a breeze.
Attached is a sample log from my local instance. Imagine how unwieldy this page would be if I needed the paste the contents of the logs directly into my case. Attachments make it easy to add additional information without having to cloud the original message.
The part I love most about attachments in cases is that they're not attachments in email. Having to worry about file size and different email servers and who's CC'd when sending an attachment becomes a real headache. What if four people got the attachment, but the fifth person's email server rejected the message? How else would I get a relatively large file? Thankfully, you can attach items up to 100mb in size to a case. Once you've created your case, you know immediately that the attachment will be available for your team to see without having to confirm with each person.
Taking attachments out of email and putting them in the case also makes it much easier to keep track of files, as the Supportal will index any text documents you attach to make them easier to find via search. No more sifting through your inbox!
Supportal: A Support Engineer's Best Friend
The Supportal offers a fantastic set of tools for us to communicate effectively with our customers to resolve issues. Prior to the Supportal, case management was via email, which was cumbersome and error-prone. It's very easy to forget to add someone to an email chain, or forget to reply-all. With the Supportal, cases are created in a secure customer space for Jive Support and the customer to see. This helps with historical case tracking and increases visibility to all authorized members of the customer's company.
Not only does the Supportal make a Support Engineer's job easier, it also makes it easier for our customers to communicate with us and get the help they need.
On most Fridays at lunch time Jive hosts an engineering-oriented talk and supplies pizza. Topics have included cool technologies people are exploring, deep dives into the design and implementations of Jive SBS functionality, overviews of new product capabilities, and even the ways in which other parts of the company work.
This past Friday we had a special guest, Dietrich Ayala of Mozilla, who gave us an overview of HTML 5 and the current and planned capabilities for Firefox as it applies to HTML 5. He covered a bunch of features of the standard, including <video/>, <audio/>, <canvas/>, Web Workers, drag and drop support, WAI-ARIA, storage, cross-document messaging, native MathML and SVG capabilities, and more. He also mentioned the html5-pdx Google group as a great way to connect with others in the Portland area.
Thanks Dietrich! We really appreciate you taking the time to talk with us.
The inaugural JiveWorld conference in October will include a technical track that will be chock-full of valuable content. I'm putting together the agenda for the track and am looking forward to starting to share details in the weeks ahead. But in order to make this conference great, we need your help. Are you the Jive technical guru at your organization? If so, we want you to participate in the tech track of the conference by becoming a speaker.
The conference will be a fantastic place to share tips and tricks as well as to learn how to get the most from the Jive platform. Interested in being a speaker but not sure about a topic? How about performance optimization tips or stories? Or, share details of the Jive customizations you've done. I'm looking forward to reading through your topic ideas and see you in October!
Hey there, Support Community!
We are very pleased to announce the release of a much requested feature...Product Issue Tracking! With this new functionality you will be able to track cases that have associated issues and view the status of the issue including the fixed versions! Here is an outline of the two major new features coming with this new release of Jive's Supportal.
Viewing status of Product Issues on the individual cases
This is now in the sidebar of a case. We are removing the bar which showed the static text of the cases and are now showing various information about the product issue, all in real time.
Here is what was previously displayed:
And here is the new view:
This allows you to quickly see if you have open or closed issues in a case. Also, if desired, you can click the "Show Details" link to expose some additional information about a product issue. It will look similar to this:
This will also show in others' public cases that have product issues attached to them. Please use public cases and spread the knowledge!
Viewing a list of all cases that have open product issues
We have also added a new tab to your account's secure space which shows a list of all cases that have at least one open product issue assigned to them. This means that you can now actively check on cases that have open issues and get real time data on them! Is it fixed? Is it still open? Check out this new functionality today! You will also have the opportunity to view all cases associated with closed product issues, as well as their resolution and fix version(s).
If you have a long list of issues, you'll notice the details box follows your browser window down, and the green highlighting tells you explicitly which product issue you're currently viewing.
If you have any questions, comments, feature requests, bug reports, etc., on this new and exciting functionality, please leave a comment or head to our Supportal Feedback space.
Thanks and enjoy,
Will
Giving customers the power to organize open support ticket priority, on the fly!
Posted by Todd West Jun 11, 2009Out with the old
In the past, when a customer wanted to check on the status of any of their open cases they would log into their secure space overview page and use the Community Open Cases widget. This widget was designed with a very simple goal in mind, just display the open cases with a bit of extra information and an emphasis on Severity 1 issues. This proved useful for quite some time and gave customers a good overview of what was going on with their community from a support perspective.
However, there was one major flaw. Customers had no way of interacting with this information and often found it very difficult to organize this data in a manner that they could use quickly and efficiently. Welcome, open cases widget 2.0!
The new and improved open cases widget
Along with our upgrade of the Supportal to SBS 3.0, I took on the job of updating this widget to provide customers with better control over their open cases. There are two major upgrades that I gave this widget which have enhanced the way people use it:
1. Cases broken down by Severity
Instead of displaying all the open cases in a potentially enormous group, I've broken down the display into 3 distinctive parts. This is especially helpful for customers with more than 10+ open support cases at a time and allows customers to quickly see if they have any Level 1 issues that they need to attend to quickly.
2. New case option available: Priority
To the right of every case status is a set of up and down buttons which control the individual priority of every issue (within their respective severity).
Okay great, so how do I use it?
Step 1: Log in
Log into the Supportal and visit your Company's secure space "Overview" tab
Step 2: Organize open cases
Browse through any open cases and use the "move up/move down" buttons to re-order them. All the moving on the screen will be done in real-time thanks to our good old friend Javascript. You may recognize these buttons from SBS, as they are used to control the location of profile fields on the admin console registration settings page.
Step 3: Don't forget to Save!
As of right now, your cases will be in the order you want on the overview page, but there is one final step. You will need to click the Save Settings button at the bottom right hand corner of the widget. This will take the current ordering of your widget and persist the case priorities to the database.
You will receive a friendly notification at the top of the widget that your Priority changes have been successfully saved, and you are done!
Well that's easy enough, how does it all work?
I'm glad you asked--it's really quite simple.
Displaying the widget
First off, the widget loads up all the non-closed cases within a secure space and puts them into three different Collections (one for each severity):
for (String caseID : caseIDs) {
try {
SupportCase supportCase = supportCaseManager.getSupportCase(Long.parseLong(caseID));
String status = supportCase.getStatus();
if (status != null && !caseStatusManager.isClosedStatus(status)) {
String severity = supportCase.getSeverity();
String priority = supportCase.getPriority();
supportCase.setPriority(priority != null ? priority : "0");
if(severity.equals("Level 1")) {
openSev1Cases.add(supportCase);
Collections.sort(openSev1Cases, new CaseComparator());
}
else if(severity.equals("Level 2")) {
openSev2Cases.add(supportCase);
Collections.sort(openSev2Cases, new CaseComparator());
}
else {
openSev3Cases.add(supportCase);
Collections.sort(openSev3Cases, new CaseComparator());
}
}
}
catch (NotFoundException e) {
log.error("Could not retreive support case in OpenCasesWidget: " + e.getMessage());
}
}
(Ideally this will get refactored soon to allow for more or less than 3 severities instead of being hard-coded. But it will work for now.)
The CaseComparator() orders all the currently open cases by their priority in the database. If nothing has yet been set, it will be put in the order that the cases were created.
The fancy effects
The cases are now sent to the template, where they are displayed in their respective severity grouping and automatically hooked into the Javascript functions that allow the up/down buttons to work. When you click on one of the buttons the following Javascript magic happens:
1. References to the required objects on the screen are loaded up using Javascript:
var moveUp = function(e, type) {
Event.stop(e);
var ansc = this.up(".case-field");
if(ansc != undefined) {
ansc.previous().insert({before: ansc});
updateHiddenField(ansc, ansc.next());
}
updateOrderingAnchors(type);
}
2. A hidden priority field for each case is updated with the new ordering value:
var updateHiddenField = function(element, newElement) {
var temp = element.select(".case-priority")[0].value;
element.select(".case-priority")[0].value = newElement.select(".case-priority")[0].value;
newElement.select(".case-priority")[0].value = temp;
}
3. The ordering of the case above (or below if the down arrow was pressed) will be swapped on screen and the list rebuilt:
var updateOrderingAnchors = function(type) {
if(type == "1") {
var elms = $("sev1-case-list-body").select("tr");
}else if(type == "2") {
var elms = $("sev2-case-list-body").select("tr");
}else{
var elms = $("sev3-case-list-body").select("tr");
}
elms.each(function(tr, i) {
var anchors = tr.select(".field-moveup")[0];
if (i <= 0) {
anchors.update("<span class='move-up-disabled'>move up</span>");
}
else {
anchors.update(new Element("a", {"class": "anchor-move-up", href: "#"}).update("move up"));
}
anchors = tr.select(".field-movedown")[0];
if (i == elms.length - 1) {
anchors.update("<span class='move-down-disabled'>move down</span>");
}
else {
anchors.update(new Element("a", {"class": "anchor-move-down", href: "#"}).update("move down"));
}
});
bindAnchors();
}
4. Now that the ordering is complete, you click the Save Settings button which makes a call to this Javascript to call a DWR method and display the nice notification at the top of the widget:
CasePriorityAction.setPriorities( values, {
callback:function() {
$('save-button').enable();
$('jive-success-box').style.display = "block";
Effect.Fade($('jive-success-box'),{delay: 3, duration: 5});
}
});
Saving the data
The final step involves saving this to the database, which is done by the call to the setPriorities DWR method as noted above. This loops through all the cases on the screen and sets the priorities in the database accordingly:
public void setPriorities(List<String> values) {
try {
for(String value : values){
String[] vars = value.split("-");
SupportCase supportCase = supportCaseManager.getSupportCase(Long.parseLong(vars[1]));
supportCase.setPriority(vars[2]);
supportCaseManager.updateSupportCase(supportCase);
}
}
catch (NotFoundException e) {
log.error("Could not retreive case in CasePriorityAction: " + e.getMessage());
}
}
I hope this information provides you with interesting insight into how our custom development allows us to work smarter and more efficiently with all our customers. We want these new features to enrich your Jive experience!
As always, Jive welcomes any and all feedback about this feature and the Supportal in general. Please comment on this post or start a discussion in our Supportal Feedback space.
-
Megan Chinburg on Release Day! 2.5.18, 3.0.9 and I'm Very Pleased to Announce: 4.0.0!
-
sydneyland on Supportal 3.3.0 brings back Product Issue tracking!
-
-
Will French on Preview of upcoming Jivespace & Supportal upgrade to SBS 4.0!
-
ccomeaux on Preview of upcoming Jivespace & Supportal upgrade to SBS 4.0!