Google Search Appliance Administrative API Developer's Guide: Java

Google Search Appliance software version 6.0
Posted June 2009

Contents

1. Introduction
   1. Getting Started
      1. Running Samples
      2. Building Your Applications
   2. Authenticating Your Google Search Appliance Account
2. Crawling and Indexing
   1. Crawl URLs
      1. Retrieving Crawl URLs
      2. Updating Crawl URLs
   2. Data Source Feeds
      1. Retrieving Data Source Feed Information
      2. Deleting Data Source Feeds
      3. Destroying Data Source Feeds
      4. Trusted Feed IP Addresses
         1. Retrieving Trusted Feed IP Addresses
         2. Updating Trusted Feed IP Addresses
   3. Crawl Schedule
      1. Retrieving the Crawl Schedule
      2. Updating the Crawl Schedule
   4. Crawler Access Rules
      1. Inserting a Crawler Access Rule
      2. Retrieving Crawler Access Rules
      3. Updating a Crawler Access Rule
      4. Deleting a Crawler Access Rule
   5. Host Load Schedule
      1. Retrieving the Host Load Schedule
      2. Updating the Host Load Schedule
   6. Freshness Tuning
      1. Retrieving the Freshness Configuration
      2. Updating the Freshness Configuration
      3. Recrawling URL Patterns
         1. Recrawling URL Patterns Example
   7. Collections
      1. Creating a Collection
      2. Retrieving All Collections
      3. Retrieving a Collection
      4. Updating a Collection
      5. Deleting a Collection
3. Serving
   1. Front Ends: Remove URLs and a Relative OneBox
      1. Retrieving Front Ends, Remove URLs, and a Relative OneBox
      2. Updating Remove URLs and a Relative OneBox
      3. Inserting Front Ends and Remove URLs
      4. Deleting a Front End
   2. Output Format XSLT Stylesheet
      1. Retrieving the Output Format XSLT Stylesheet
      2. Updating the Output Format XSLT Stylesheet
   3. KeyMatch Settings
      1. Retrieving KeyMatch Settings
      2. Changing KeyMatch Settings
   4. Related Queries
      1. Retrieving Related Queries
      2. Changing Related Queries
   5. OneBox Modules Settings
      1. Retrieving OneBox Module Settings
      2. Updating OneBox Module Settings
   6. OneBox Modules Retrieve and Delete
      1. Retrieving OneBox Module Information
      2. Deleting a OneBox Module
4. Status and Reports
   1. Pause or Resume Crawl
      1. Retrieving Crawl Status
   1. Pausing or Resuming Crawl
   2. Serving Status
      1. Retrieving Serving Status
   3. System Status
      1. Retrieving System Status
   4. Document Status
      1. Retrieving Document Status
   5. Crawl Diagnostics
      1. Document Status Values
      2. Listing Documents
      3. Viewing Crawl Diagnostics for a Document
   6. Content Statistics
      1. Retrieving Content Statistics For All Crawled Files
      2. Retrieving Content Statistics For a Crawled File
   7. Search Reports
      1. Listing a Search Report
      2. Creating a Search Report
      3. Retrieving a Search Report
      4. Updating a Search Report
      5. Deleting a Search Report
   8. Search Logs
      1. Listing a Search Log
      2. Creating a Search Log
      3. Retrieving a Search Log
      4. Updating a Search Log
      5. Deleting a Search Log
   9. Event Log
      1. Retrieving an Event Log
5. Connector Administration
   1. Connector Managers
   2. Adding a Connector Manager
   3. Retrieving a List of Connector Managers
   4. Updating a Connector Manager
   5. Deleting a Connector Manager
6. Federation
   1. Configuring a Federation Network
   2. Adding a Federation Node
   3. Retrieving a Node Configuration
   4. Retrieving All Node Configurations
   5. Updating a Node Configuration
   6. Deleting a Node
7. Administration
   1. License Information
      1. Retrieving License Information
         1. Retrieving License Information Example
   2. Reset Index
      1. Retrieving Status of a Reset Index
      2. Resetting the Index
   3. Import and Export
      1. Exporting a Configuration
      2. Importing a Configuration
   4. Shutdown or Reboot
      1. Shutting Down or Rebooting

Introduction

This guide provides Java programming information about how to use the Google Data API to create, retrieve, update, and delete information for one or more Google Search Appliance devices.

Use the information in this guide to create or learn about coding Java applications that programmatically set the administrative functions for the Admin Console of a search appliance.

The audience for this guide is Java programmers who want to programmatically configure a Google Search Appliance. Before using the Google Search Appliance Administrative API, read Getting Started to download and configure required software.

Note: This guide uses data source feed to indicate the search appliance's Feeds API (described in the Feeds Protocol Developer's Guide).

The organization of this guide corresponds to the navigation features of the Google Search Appliance:

• Crawling and Indexing
• Serving
• Status and Reports
• Connector Administration
• Federation
• Administration

Getting Started

The google-enterprise-gdata-api open source site provides ZIP files that contain the Java client library, source code and some sample applications for your reference. The information in this section helps you understand how to write your own applications based on the client library and how to run the provided open source sample applications. You can also use the sample applications as models for your own development.

Before starting, you need the following software:

• JDK version 5.0 or later available from Java.com downloads.
• Apache Ant version 1.7 or later.
• Admin Console user name and password for the search appliance to which you direct your commands.

After you download the software and acquire search appliance credentials, get started as follows:

1. Browse to the Administrative API download site.
2. Download the ZIP file gsa-admin-api-java-1.0.1.zip containing the client library and the sample application files.
3. Unzip the file and navigate to the gdata/java folder. The client library JAR files are present in the lib folder and the sample applications are present in the sample folder.

Running Samples

Sample applications are located in the gdata/java/sample folder.

To see if you've installed the required software correctly, open a command prompt and change directory to the gdata/java folder. Enter the following command:

ant -f build-samples.xml sample.dashboard.run 

This command displays build output messages and opens an example dashboard that demonstrates the features of the Google Search Appliance Administrative API. You can add your search appliance configuration information to the dashboard and see the dashboard running.

To find out how to run each sample, go to gdata/java/build-samples folder and view the build file for each sample, like dashboard.xml, commandline.xml, and aclclient.xml. Look for the samples run comment. Another example of how to run the commandline sample application, enter the following command in the gdata/java folder:

ant -f build-samples.xml -Dargs="retrieve --hostname=gsa_hostname --username=gsa_user 
--password=gsa_passwd --protocol=http --port=gsa_port config crawlURLs" sample.commandline.run 

Substitute these parameters:

• gsa_hostname -- The host name of a search appliance (specify just the host name, not the domain name)
• gsa_port -- Port 8000, access to the Admin Console on the search appliance
• gsa_user -- The user name for the Admin Console on the search appliance
• gsa_password -- The password for the Admin Console on the search appliance

For example:

ant -f build-samples.xml -Dargs='retrieve --hostname=gsa42.corp.example.com --username=admin  
--password=greenparrot --protocol=http --port=8000 config crawlURLs' sample.commandline.run 

This command displays the crawl URLs for a search appliance.

The commandline sample application requires that command line arguments be passed to Ant by using the -Dargs option in the commandline.xml file.

Building Your Applications

You can build your own applications using the client library.

Copy the following client library JAR files from the gdata/java/lib folder to your development folder and add the files to your classpath environmental system variable:

• gdata-core-1.0.jar
• gdata-gsa-1.0.jar
• gdata-client-1.0.jar
• gdata-client-meta-1.0.jar
• gdata-gsa-meta-1.0.jar

You can then use the JAR files in your application.

Authenticating Your Google Search Appliance Account

Before making API calls with the Java client library, you must construct a new GsaClient object.

In the constructor that follows, replace gsaAddr with the host name of a search applaiance, gsaPort with port 8000, myUserId and myPassword with your Admin Console authentication information:

import com.google.enterprise.apis.client.GsaClient;
GsaClient myClient = new GsaClient("gsaAddr", gsaPort, "myUserId", "myPassword");

For example:

import com.google.enterprise.apis.client.GsaClient;
GsaClient myClient = new GsaClient("gsa42.corp.example.com", 8000, "admin", "greenparrot");

Crawling and Indexing

The sections that follow describe how to configure the Crawling and Indexing features of the Admin Console:

• Crawl URLs
• Data Source Feeds
• Crawl Schedule
• Crawler Access Rules
• Host Load Schedule
• Freshness Tuning
• Collections

Crawl URLs

Retrieve and update crawl URL patterns on a search appliance using the crawlURLs entry of the config feed.

Retrieving Crawl URLs

Retrieve information about the URL patterns that the search appliance is crawling as follows:

// Send a request and print the response
GsaEntry myEntry = myClient.getEntry("config", "crawlURLs");
System.out.println("Start URLs: " + myEntry.getGsaContent("startURLs"));
System.out.println("Follow URLs: " + myEntry.getGsaContent("followURLs"));
System.out.println("Do Not Crawl URLs: " + myEntry.getGsaContent("doNotCrawlURLs"));

Updating Crawl URLs

Update the crawl URL settings on a search appliance as follows -- in the example that follows, example.com is requested for crawling, and spreadsheets are requested to not be crawled.

// Create an entry to hold properties to update
GsaEntry updateEntry = new GsaEntry();
updateEntry.setId(entryUrl);


// Add a property for adding crawl URLs to updateEntry
updateEntry.addGsaContent("startURLs", "http://www.example.com/");
updateEntry.addGsaContent("followURLs", "http://www.example.com/");
updateEntry.addGsaContent("doNotCrawlURLs", ".xls$");

// Send the request
myClient.updateEntry("config", "crawlURLs", updateEntry);

Data Source Feeds

Retrieve, delete, and destroy data source feed information for the search appliance using the feed feed. The following parameters let you search for a string and retrieve source statements.

Use the following properties to view data source feed records and content.

Note: You can only get information about data source feeds, and delete or destroy data source feeds. Inserting new data source feeds is not provided by this API. You can create new feeds using the Admin Console user interface.

Retrieving Data Source Feed Information

Retrieve all data source feed information from a search appliance using the feed feed:

// Send a request and print the response
Map<String, String> queries = new HashMap<String, String>(); 
queries.put("query",feedDataSource); 
GsaFeed myFeed = myClient.queryFeed("feed", queries);

for(GsaEntry myEntry : myFeed.getEntries()) {
  //get information on each myEntry
  System.out.println("Feed Name: " + myEntry.getGsaContent("entryID"));
  System.out.println("Feed Data Source: " + myEntry.getGsaContent("feedDataSource"));
  System.out.println("Feed Type: " + myEntry.getGsaContent("feedType"));
  System.out.println("Feed State: " + myEntry.getGsaContent("feedState"));
  System.out.println("Feed Time: " + myEntry.getGsaContent("feedTime"));
  System.out.println("Error Records: " + myEntry.getGsaContent("errorRecords"));
  System.out.println("Success Records: " + myEntry.getGsaContent("successRecords"));
  System.out.println("Log Content: " + myEntry.getGsaContent("logContent"));
}

You can get the individual feed information from a search appliance as follows:

GsaEntry myEntry = myClient.getEntry("feed", FEED_NAME);
System.out.println("Feed Data Source: " + myEntry.getGsaContent("feedDataSource"));
System.out.println("Feed Type: " + myEntry.getGsaContent("feedType"));
System.out.println("Feed State: " + myEntry.getGsaContent("feedState"));
System.out.println("Feed Time: " + myEntry.getGsaContent("feedTime"));
System.out.println("Error Records: " + myEntry.getGsaContent("errorRecords"));
System.out.println("Success Records: " + myEntry.getGsaContent("successRecords"));
System.out.println("Log Content: " + myEntry.getGsaContent("logContent"));

Note: A feed log of all data source feeds can be retrieved only by getting individual feeds.

Deleting Data Source Feeds

Delete a data source feed to remove all documents for a feed from the index on the search appliance. In the Admin Console, deleted feed sources are marked with Delete.

Delete data source feeds as follows:

// Create an entry to hold properties to update
GsaEntry updateEntry = new GsaEntry();


// Add a property to updateEntry
updateEntry.addGsaContent("updateMethod", "delete");
myClient.updateEntry("feed", FEED_NAME, updateEntry);

Note: Delete data source feeds only of the type FULL_FEED or incremental. After deleting a data source feed, the deleted feed still exists, and the feed type changes to DELETED.

Destroying Data Source Feeds

After deleting a data source feed, you can destroy the feed so that the feed no longer exists on the search appliance:

myClient.deleteEntry("feed", FEED_NAME);

Trusted Feed IP Addresses

Retrieve and update trusted feed IP addresses using the feedTrustedIP entry of the config feed.

Retrieve the IP addresses of trusted feeds using the trustedIPs property.

Retrieving Trusted Feed IP Addresses

Retrieve the trusted feed IP addresses as follows:

// Send the request and print the response
GsaEntry myEntry = myClient.getEntry("config ", "feedTrustedIP");
System.out.println("Trusted IP Addresses: " + myEntry.getGsaContent("trustedIPs"));

Updating Trusted Feed IP Addresses

Update trusted feed IP addresses as follows:

// Create an entry to hold properties to update
GsaEntry updateEntry = new GsaEntry();
updateEntry.setId(entryUrl);
    
// Add a property for the feeds trusted IP addresses 
//  to updateEntry
updateEntry.addGsaContent("trustedIPs", "127.0.0.1");
    
// Send the request
myClient.updateEntry("config", "feedTrustedIP", updateEntry);

Crawl Schedule

Retrieve and update the crawl schedule for a search appliance.

Day,Time,Duration

Retrieving the Crawl Schedule

Retrieve the crawl mode and get the crawl schedule as follows:

GsaEntry myEntry = myClient.getEntry("config", "crawlSchedule");
System.out.println("Is Scheduled Crawl: " + myEntry.getGsaContent("isScheduledCrawl"));
System.out.println("Crawl Schedule: " + myEntry.getGsaContent("crawlSchedule"));

Updating the Crawl Schedule

Update the crawl schedule or crawl mode as follows:

// Create an entry to hold properties to update
GsaEntry updateEntry = new GsaEntry();
updateEntry.setId(entryUrl);


// Add a property to updateEntry
updateEntry.addGsaContent("isScheduledCrawl", "1");
updateEntry.addGsaContent("crawlSchedule", "0,0300,360\n2,0000,1200");

// Send the request
myClient.updateEntry("config", "crawlSchedule", updateEntry);

Crawler Access Rules

Create, retrieve, update, and delete crawler access rules for a search appliance.

Crawler access rules instruct the crawler how to authenticate when crawling the protected content.

Inserting a Crawler Access Rule

Insert a new crawler access rule as follows:

// Create an entry to hold properties to insert
GsaEntry insertEntry = new GsaEntry();


// Add properties to insertEntry
insertEntry.addGsaContent("entryID", "#URL pattern for the new crawler access rule");
insertEntry.addGsaContent("domain", "domainone");
insertEntry.addGsaContent("isPublic", "1");
insertEntry.addGsaContent("username", "username");
insertEntry.addGsaContent("password", "password");

// Send the request
myClient.insertEntry("crawlAccessNTLM", insertEntry);

Retrieving Crawler Access Rules

Retrieve a list of crawler access rules as follows:

// Send a request and print the response
GsaFeed myFeed = myClient.getFeed("crawlAccessNTLM");

for(GsaEntry myEntry : myFeed.getEntries()) {
  System.out.println("URL Pattern: " + myEntry.getGsaContent("urlPattern"));
  System.out.println("User Name: " + myEntry.getGsaContent("username"));
  System.out.println("Order: " + myEntry.getGsaContent("order"));
  System.out.println("Domain: " + myEntry.getGsaContent("domain"));
  System.out.println("Is Public: " + myEntry.getGsaContent("isPublic"));
}

Retrieve an individual crawler access rule as follows:

// Send the request and print the response
GsaEntry myEntry = myClient.getEntry("crawlAccessNTLM", "urlPattern");
System.out.println("URL Pattern: " + myEntry.getGsaContent("urlPattern"));
System.out.println("User Name: " + myEntry.getGsaContent("username"));
System.out.println("Order: " + myEntry.getGsaContent("order"));
System.out.println("Domain: " + myEntry.getGsaContent("domain"));
System.out.println("Is Public: " + myEntry.getGsaContent("isPublic"));

Note:The password property doesn't appear when retrieving crawler access rules.

Updating a Crawler Access Rule

Update a crawler access rule as follows:

// Create an entry to hold properties to update
GsaEntry updateEntry = new GsaEntry();
updateEntry.setId(entryUrl);


// Add properties to updateEntry
updateEntry.addGsaContent("urlPattern", "#new URL pattern");
updateEntry.addGsaContent("domain", "newdomain");
updateEntry.addGsaContent("isPublic", "0");
updateEntry.addGsaContent("order", "2");
updateEntry.addGsaContent("username", "newuser");
updateEntry.addGsaContent("password", "newpass");

// Send the request
myClient.updateEntry("crawlAccessNTLM", "urlPattern", updateEntry);

Deleting a Crawler Access Rule

Delete a crawler access rule as follows:

myClient.deleteEntry("crawlAccessNTLM", "urlPattern");

Host Load Schedule

Retrieve and update host load schedule information from the search appliance using the hostLoad entry of the config feed.

hostName startTime endTime loadFactor

Retrieving the Host Load Schedule

Retrieve information about the host load schedule from a search appliance as follows:

// Send the request and print the response
myEntry = myClient.getEntry("config", "hostLoad");
System.out.println("defaultHostLoad: " + myEntry.getGsaContent("defaultHostLoad"));
System.out.println("exceptionHostLoad: " + myEntry.getGsaContent("exceptionHostLoad"));
System.out.println("maxURLs: " + myEntry.getGsaContent("maxURLs"));

Updating the Host Load Schedule

Update the host load schedule setting in a search appliance as follows:

// Create an entry to hold properties to update
GsaEntry updateEntry = new GsaEntry();
updateEntry.setId(entryUrl);

// Add a property for the Host Load Schedule to updateEntry
updateEntry.addGsaContent("defaultHostLoad", "2.4");
updateEntry.addGsaContent("exceptionHostLoad", "* 3 5 1.2 \n www.example.com 1 6 3.6");
updateEntry.addGsaContent("maxURLs", "3000");

// Send the request
myClient.updateEntry("config", "hostLoad", updateEntry);

Freshness Tuning

Increase or decrease the crawling frequency by specifying URL patterns.

Retrieving the Freshness Configuration

Retrieve the freshness tuning configuration as follows:

GsaEntry myEntry = myClient.getEntry("config", "freshness");
System.out.println("Archive URLs: " + myEntry.getGsaContent("archiveURLs"));
System.out.println("Frequent URLs: " + myEntry.getGsaContent("frequentURLs"));
System.out.println("Force URLs: " + myEntry.getGsaContent("forceURLs"));

Updating the Freshness Configuration

Update the settings for freshness tuning as follows:

// Create an entry to hold properties to update
GsaEntry updateEntry = new GsaEntry();
updateEntry.setId(entryUrl);


// Add a property for updateEntry
updateEntry.addGsaContent("archiveURLs", "http://good/");
updateEntry.addGsaContent("frequentURLs", "http://frequent/");
updateEntry.addGsaContent("forceURLs", "http://force/");
  
// Send the request
myClient.updateEntry("config", "freshness", updateEntry);

Recrawling URL Patterns

If you discover that a set of URLs that you want to have in the search index are not being crawled you can inject a URL pattern into the queue of URLs that the search appliance is crawling. URLs may not appear in the index because changes were made to the web pages, or because a temporary error or misconfiguration was present when the crawler last tried to crawl the URL.

Recrawling URL Patterns Example

Recrawl URL patterns as follows:

// Create an entry to hold properties to update
GsaEntry updateEntry = new GsaEntry();
  
// Add a property to updateEntry
updateEntry.addGsaContent("recrawlURLs", "http://recrawl/page.html");
  
// Send the request
myClient.updateEntry("command", "recrawlNow", updateEntry);

Collections

Retrieve, update, create, or delete the collections of documents on the search appliance.

Creating a Collection

Create a new collection as follows:

// Create an entry to hold properties to insert
GsaEntry insertEntry = new GsaEntry();
  
// Add a property to insertEntry
insertEntry.addGsaContent("collectionName", "new_collection");
insertEntry.addGsaContent("insertMethod", "default");

// Send the request
myClient.insertEntry("collection", insertEntry);

Create a new collection with a default setting as follows:

insertEntry.addGsaContent("insertMethod", "default");

Specify the settings for a new collection as follows:

// Add property for insertEntry
insertEntry.addGsaContent("collectionName", "new_collection");
insertEntry.addGsaContent("insertMethod", "customize");
insertEntry.addGsaContent("followURLs", "#url to follow");
insertEntry.addGsaContent("doNotCrawlURLs", "#url to not follow");

Retrieving All Collections

Retrieve a list of collections as follows:

// Send the request and print the response
GsaFeed myFeed = myClient.getFeed("collection");

for(GsaEntry myEntry : myFeed.getEntries()) {
  System.out.println("Follow URLs: " + myEntry.getGsaContent("followURLs"));
  System.out.println("Do Not Crawl URLs: " + myEntry.getGsaContent("doNotCrawlURLs"));
}

Retrieving a Collection

Retrieve the attributes of a single collection as follows:

// Send the request and print the response
GsaEntry myEntry = myClient.getEntry("collection", "default_collection");
System.out.println("Follow URLs: " + myEntry.getGsaContent("followURLs"));
System.out.println("Do Not Crawl URLs: " + myEntry.getGsaContent("doNotCrawlURLs"));

Updating a Collection

Update the attributes of a collection as follows:

// Create an entry to hold properties to update
GsaEntry updateEntry = new GsaEntry();
updateEntry.setId(entryUrl);


// Add properties to updateEntry
updateEntry.addGsaContent("followURLs", "http://good/");
updateEntry.addGsaContent("doNotCrawlURLs", "http://frequent/");
  
// Send the request
myClient.updateEntry("collection", "default_collection", updateEntry);

Deleting a Collection

Delete a collection as follows:

myClient.deleteEntry("collection", "new_collection");

Serving

The sections that follow describe how to configure the Serving features of the Admin Console:

• Front Ends: Remove URLs and a Relative OneBox
• Output Format XSLT Stylesheet
• KeyMatch Settings
• Related Queries
• OneBox Modules Settings
• OneBox Modules Retrieve and Delete
• Document Status
• Crawl Diagnostics

Front Ends: Remove URLs and a Relative OneBox

Retrieve, update, insert, or delete front ends to remove URLs or a relative OneBox for the search appliance using the frontend feed. Retrieve a front end using the following properties.

Retrieving Front Ends, Remove URLs, and a Relative OneBox

Retrieve all the front end information for a search appliance as follows:

// Send a request and print the response
GsaFeed myFeed = myClient.getFeed("frontend");

for(GsaEntry myEntry : myFeed.getEntries()) {
  //get information for each myEntry
}

Get information about a front end as follows:

// Send a request and print the response
GsaEntry myEntry = myClient.getEntry("frontend", FRONTEND_NAME);
System.out.println("Front End OneBox: " + myEntry.getGsaContent("frontendOnebox"));
System.out.println("Remove URLs: " + myEntry.getGsaContent("removeUrls"));

Updating Remove URLs and a Relative OneBox

Update the URLs to remove from the search results, and update a OneBox module in a front end as follows:

// Create an entry to hold properties to update
GsaEntry updateEntry = new GsaEntry();
updateEntry.setId(entryUrl);


// Add properties to updateEntry
updateEntry.addGsaContent("frontendOnebox", "oneboxtwo");
updateEntry.addGsaContent("removeUrls", "http://www.example.com/");

// Send the request
myClient.updateEntry("frontend", FRONTEND_NAME, updateEntry);

Inserting Front Ends and Remove URLs

Insert a front end and remove a URL from the search results as follows:

// Create an entry to hold properties to insert
GsaEntry insertEntry = new GsaEntry();
insertEntry.setId(entryUrl);


// Add properties to insertEntry
insertEntry.addGsaContent("entryID", FRONTEND_NAME);
insertEntry.addGsaContent("removeUrls", "http://www.example3.com/");
    
// Send the request
myClient.insertEntry("frontend", insertEntry);

Deleting a Front End

Delete a front end from the search appliance as follows:

myClient.deleteEntry("frontend", FRONTEND_NAME);

Output Format XSLT Stylesheet

Retrieve and update the XSLT template and other output format-related properties for each language of each front end using the frontend entry of the outputFormat feed.

Use the following properties to access the XSLT template information.

Note: For the update action, the restoreDefaultFormat content is mutually exclusive from the styleSheetContent. For each update action, you should either restore the output format XSLT stylesheet back to the original default values, set the XSLT stylesheet to a custom format, or neither, but not both.

Retrieving the Output Format XSLT Stylesheet

Retrieve the output format stylesheet information from a search appliance as follows:

Map<String, String> queryMap = new HashMap<String, String>();
    
// Initialize the query map
queryMap.put("language", "en");
GsaEntry myEntry = myClient.queryEntry("outputFormat", "default_frontend", queryMap);
System.out.println("Language: " + myEntry.getGsaContent("language"));
System.out.println("Default Language: " + myEntry.getGsaContent("isDefaultLanguage"));
System.out.println("Is the Style Sheet Edited: " + myEntry.getGsaContent("isStyleSheetEdited"));
System.out.println("XSLT Stylesheet Content: " + myEntry.getGsaContent("styleSheetContent"));

Updating the Output Format XSLT Stylesheet

Update the output format stylesheet information in a search appliance as follows:

// Create an entry to hold properties to update
GsaEntry updateEntry = new GsaEntry();
updateEntry.setId("default_frontend");
    
// The language parameter is passed as part of 
//  the entry because we cannot use a query parameter
updateEntry.addGsaContent("language", "en");
    
// Indicate that the XSLT stylesheet has default values
updateEntry.addGsaContent("isDefaultLanguage, "1");
    
// Add this line to update the style sheet content
updateEntry.addGsaContent("styleSheetContent", "{my new style sheet XSLT}");

// Or add this line to restore the stylesheet content to 
// the default, which is mutually exclusive from the previous line
updateEntry.addGsaContent("restoreDefaultFormat", "1");
    
// Send the request and print the response
myClient.updateEntry("outputFormat", "default_frontend", updateEntry);
System.out.println("Output Format: " + updateEntry.getGsaContent("outputFormat"));
System.out.println("Default Front End: " + updateEntry.getGsaContent("default_frontend"));

KeyMatch Settings

KeyMatch settings let you promote specific web pages on your site. The following parameters let you find KeyMatches by search, and specify a starting line number and the number of lines to access.

Use the following properties to set KeyMatch configurations.

Note: The format for a KeyMatch configuration rule is as follows:
   Search_Terms,KeyMatch_Type,URL,Title

KeyMatch_Type can be: KeywordMatch, PhraseMatch, or ExactMatch.
Search_Term and URL fields cannot be empty. The KeyMatch configuration conforms to the CSV format, which uses commas to separate values.

Retrieving KeyMatch Settings

Retrieve KeyMatch settings as follows:

index Map<String, String> queryMap = new HashMap<String, String>();
  
// Initialize the query
map queryMap.put("query", "myQuery");
queryMap.put("startLine", "0");
queryMap.put("maxLines", "50");
  
// Send the request and print the response
GsaEntry myEntry = myClient.getEntry("keymatch", "myFrontend", queryMap);
Iterator i = myEntry.getAllGsaContents().entrySet().iterator();
while (i.hasNext()) {
  Map.Entry me = (Map.Entry)i.next();
  if (me.getKey().matches("\\d+")) {
    System.out.println("The lines for " + my.getKey() + " are: " + my.getValue()); 
  }
}
System.out.println("The number of lines are: " + myEntry.getGsaContent("numLines"));

Changing KeyMatch Settings

The following example appends KeyMatch settings:

// Create an entry to hold properties to append
GsaEntry appendEntry = new GsaEntry();
appendEntry.setId("myFrontend");
appendEntry.addGsaContent("updateMethod", "append");
 
// Prepare new content
String newLines = 
  "image,KeywordMatch,http://images.google.com/,Google Image Search\n" +
  "video,KeywordMatch,http://www.youtube.com/,Youtube\n" +
  "rss feed,PhraseMatch,http://www.google.com/reader,Reader";
appendEntry.addGsaContent("newLines", newLines);
  
// Send the request to the search appliance
myClient.updateEntry("keymatch", "myFrontend", appendEntry);

The following example updates KeyMatch settings:

// Create an entry to hold properties to update
GsaEntry updateEntry = new GsaEntry();
updateEntry.setId("myFrontend");
updateEntry.addGsaContent("updateMethod", "update");
  
// Set the start line number
updateEntry.addGsaContent("startLine", 0);
  
// Provide the original content
String originalLines = 
  "image,KeywordMatch,http://images.google.com/,Google Image Search\n" +
  "video,KeywordMatch,http://www.youtube.com/,Youtube\n" +
  "rss feed,PhraseMatch,http://www.google.com/reader,Reader";
updateEntry.addGsaContent("originalLines", originalLines);
  
// Prepare new content
String newLines = 
  ",,,\n" +
  "video,KeywordMatch,http://video.google.com/,Video Search\n" +
  "rss feed,PhraseMatch,http://www.example.com/,RSS example";
updateEntry.addGsaContent("newLines", newLines);
  
// Send the request to the search appliance
myClient.updateEntry("keymatch", "myFrontend", updateEntry);

Note: Delete a setting by changing the statement to three commas (,,,).

The following example replaces KeyMatch settings:

// Create an entry to hold properties to replace
GsaEntry replaceEntry = new GsaEntry();
replaceEntry.setId("myFrontend");
replaceEntry.addGsaContent("updateMethod", "replace");
  
// Prepare new content
String newLines = 
  "image,KeywordMatch,http://images.google.com/,Google Image Search\n" +
  "video,KeywordMatch,http://www.youtube.com/,Youtube\n" +
  "rss feed,PhraseMatch,http://www.google.com/reader,Reader";
replaceEntry.addGsaContent("newLines", newLines);
  
// Send the request to the search appliance
myClient.updateEntry("keymatch", "myFrontend", replaceEntry);

Related Queries

Use related queries to associate alternative words or phrases with specified search terms. Related queries are also known as synonyms. Use the following parameters to search for a query and access lines from a starting line number and for a maximum amount of lines.

Use the following properties to access related queries.

Note: A related query configuration rule is in the following format:
   Search_Terms,Related_Queries

The Search_Terms and the Related_Queries values cannot be empty. The related query configuration rules conform to the CSV format, which uses commas to separate values.

Retrieving Related Queries

Retrieve related queries as follows:

Map<String, String> queryMap = new HashMap<String, String>();
    
// Initialize the query map
queryMap.put("query", "myQuery");
queryMap.put("startLine", "0");
queryMap.put("maxLines", "50");
    
// Send the request and print the response
GsaEntry myEntry = myClient.getEntry("synonym", "myFrontend", queryMap);

Iterator i = myEntry.getAllGsaContents().entrySet().iterator();
while (i.hasNext()) {
  Map.Entry me = (Map.Entry)i.next();
  if (me.getKey().matches("\\d+")) 
  {
    System.out.println("The line " + my.getKey() + " is: " + my.getValue());
  }
}

Changing Related Queries

The following example appends related queries:

// Create an entry to hold properties to append
GsaEntry appendEntry = new GsaEntry();
appendEntry.setId("myFrontend");
appendEntry.addGsaContent("updateMethod", "append");
  
// Prepare new content
String newLines = "airplane,aircraft\n" + "google,googol\n" + "stock,security";
appendEntry.addGsaContent("newLines", newLines);
  
// Send the request to the search appliance
myClient.updateEntry("synonym", "myFrontend", appendEntry);

The following example updates related queries:

// Create an entry to hold properties to update
GsaEntry updateEntry = new GsaEntry();
updateEntry.setId("myFrontend");
updateEntry.addGsaContent("updateMethod", "update");
  
// Set the starting line number
updateEntry.addGsaContent("startLine", 0);
  
// Provide the original content
String originalLines = "airplane,aircraft\ngoogle,googol";
updateEntry.addGsaContent("originalLines", originalLines);
  
// Prepare new content
String newLines = "airplane,helicopter\n,";
updateEntry.addGsaContent("newLines", newLines);
  
// Send the request to the search appliance
myClient.updateEntry("synonym", "myFrontend", updateEntry);

Note: Delete a setting by changing the statement to a comma (,) value.

The following example replaces related queries:

// Create an entry to hold properties to replace
GsaEntry replaceEntry = new GsaEntry();
replaceEntry.setId("myFrontend");
replaceEntry.addGsaContent("updateMethod", "replace");
  
// Prepare new content
String newLines = "airplane,aircraft\n" + "google,googol\n" + "stock,security";
replaceEntry.addGsaContent("newLines", newLines);
  
// Send the request to the search appliance
myClient.updateEntry("synonym", "myFrontend", replaceEntry);

OneBox Modules Settings

Retrieve and update OneBox module settings for the search appliance using the config feed.

Retrieving OneBox Module Settings

Retrieve OneBox information for a search appliance as follows:

// Send the request and print the response
GsaEntry myEntry = myClient.getEntry("config", "oneboxSetting");
System.out.println("Max Results: " + myEntry.getGsaContent("maxResults"));
System.out.println("Timeout: " + myEntry.getGsaContent("timeout"));

The properties for retrieving a OneBox are as follows:

Updating OneBox Module Settings

Update the OneBox settings for a search appliance as follows -- in this example three results are requested and the timeout is set to 2000 milliseconds.

// Create an entry to hold properties to update
GsaEntry updateEntry = new GsaEntry();
updateEntry.setId(entryUrl);


// Add properties for the OneBox settings to updateEntry
updateEntry.addGsaContent("maxResults", "3");
updateEntry.addGsaContent("timeout", "2000");
    
// Send the request
myClient.updateEntry("config", "oneboxSetting", updateEntry);

OneBox Module Retrieve and Delete

Retrieve and delete OneBox modules from the search appliance using the onebox feed.

Note: Inserting a new OneBox module, updating an existing OneBox module, and retrieving a detailed configuration of a OneBox module are not supported by this API.

Retrieving OneBox Module Information

Retrieve information about all the OneBox modules from a search appliance using the onebox feed:

// Send the request and print the response
GsaFeed myFeed = myClient.getFeed("onebox");

for(GsaEntry myEntry : myFeed.getEntries()) {
  // Get information on each myEntry
  System.out.println("OneBox Name: " + myEntry.getGsaContent("entryID"));
}

Note: Because detailed information about the OneBox configuration not supported by this API, the onebox feed provides only OneBox module names.

Retrieve an individual OneBox module's log information from a search appliance as follows:

// Send the request and print the response
GsaEntry myEntry = myClient.getEntry("onebox",ONEBOX_NAME);
System.out.println("OneBox Log: " + myEntry.getGsaContent("logContent"));

Note: You can only retrieve OneBox log entries individually.

Deleting a OneBox Module

Delete a OneBox module from a search appliance as follows:

myClient.deleteEntry("onebox", ONEBOX_NAME);

Status and Reports

The sections that follow describe how to configure the Status and Reports features of the Admin Console:

• Pause or Resume Crawl
• Serving Status
• System Status
• Document Status
• Crawl Diagnostics
• Content Statistics
• Search Reports
• Search Logs
• Event Log

Pause or Resume Crawl

Check crawl status, pause the crawl, or resume the crawl.

Retrieving Crawl Status

Retrieve the status of crawl as follows:

// Send the request and print the response
GsaEntry myEntry = myClient.getEntry("command", "pauseCrawl");
System.out.println("Pause Crawl: " + myEntry.getGsaContent("pauseCrawl"));

Pausing or Resuming Crawl

Pause or resume a crawl as follows:

// Create an entry to hold properties to update
GsaEntry updateEntry = new GsaEntry();


// Add properties to updateEntry
updateEntry.addGsaContent("pauseCrawl", "0");
updateEntry.addGsaContent("doNotCrawlURLs", "http://frequent/");

// Send the request
myClient.updateEntry("command", "pauseCrawl", updateEntry);

Serving Status

Retrieve the serving status for the search appliance using the servingStatus entry of the status feed.

Retrieving Serving Status

Retrieve the current search appliance serving status as follows:

GsaEntry myEntry = myClient.getEntry("status", "servingStatus");
System.out.println("Queries Per Minute: " + myEntry.getGsaContent("queriesPerMinute"));

System Status

System status for the search appliance can be retrieved through the systemStatus entry of the status feed.

Note: Some health properties may not exist in certain versions of the search appliance.

Retrieving System Status

Retrieve a the current search appliance system status as follows:

GsaEntry myEntry = myClient.getEntry("status", "systemStatus");
System.out.println("Overall Health: " + myEntry.getGsaContent("overallHealth"));
System.out.println("Disk Capacity: " + myEntry.getGsaContent("diskCapacity"));
System.out.println("RAID Health: " + myEntry.getGsaContent("raidHealth"));
System.out.println("CPU Temperature: " + myEntry.getGsaContent("cpuTemperature"));
System.out.println("Machine Health: " + myEntry.getGsaContent("machineHealth"));

Document Status

Retrieve document status using the properties that follow.

Retrieving Document Status

Retrieve the document status as follows:

GsaEntry myEntry = myClient.getEntry("status", "documentStatus");
System.out.println("Served URLs: " + myEntry.getGsaContent("servedURLs"));
System.out.println("Crawled Pages Per Second: " + myEntry.getGsaContent("crawlPagePerSecond"));
System.out.println("Crawled URLs Today: " + myEntry.getGsaContent("crawledURLsToday"));
System.out.println("Found URLs: " + myEntry.getGsaContent("foundURLs"));
System.out.println("Filtered Bytes: " + myEntry.getGsaContent("filteredBytes"));
System.out.println("Error URLs Today: " + myEntry.getGsaContent("errorURLsToday"));

Crawl Diagnostics

List crawled documents and retrieve the status of documents in a search appliance using the diagnostics feed.

Document Status Values

The following tables list the document status values.

Note: Use the all to indicate any status value.

Successful Crawl:

Crawl Errors:

Crawl Exclusions:

Listing Documents

Query parameters:

List documents by sending an authenticated GET request to the root entry of the diagnostics feed.

A description entry, a set of document status entries and a set of directory status entries are returned.

Description entry properties:

Directory status entry properties:

Document status entry properties:

Example:

Map<String, String> queries = new HashMap<String, String>();
queries.put("uriAt","http://server.com/secured/test1/");
GsaFeed myFeed = myClient.queryFeed("diagnostics", queries);

for(GsaEntry entry : myFeed.getEntries()) {
   System.out.println(entry.getGsaContent("entryID"));
 if (entry.getGsaContent("entryID").equals("description")) {
   System.out.println("Number of Pages: " + entry.getGsaContent("numPages"));
   System.out.println("URI At: " + entry.getGsaContent("uriAt"));
 } else if (entry.getGsaContent("type").equals("DirectoryContentData" )||
     entry.getGsaContent("type") .equals("HostContentData")) {
     System.out.println("Type: " + entry.getGsaContent("type"));
     System.out.println("Number of Crawled URLs: " + entry.getGsaContent("numCrawledURLs"));
     System.out.println("Number of Retrieval Errors: " + entry.getGsaContent("numRetrievalErrors"));
     System.out.println("Number of Excluded URLs: " + entry.getGsaContent("numExcludedURLs"));
 } else if (entry.getGsaContent("type").equals("FileContentData")) {
     System.out.println("Type: " + entry.getGsaContent("type"));
     System.out.println("Time Stamp: " + entry.getGsaContent("timeStamp"));
     System.out.println("Document State: " + entry.getGsaContent("docState"));
     System.out.println("Page Rank: " + entry.getGsaContent("pageRank"));
     System.out.println("Is Cookie Server Error: " + entry.getGsaContent("isCookieServerError"));
 }
}

Viewing Crawl Diagnostics for a Document

Retrieve detailed information about a document by sending an authenticated GET request to a document status entry of the diagnostics feed. The parameter is as follows.

A detailed document status entry is returned.

Detailed document status entry properties:

GsaEntry entry = myClient.getEntry("diagnostics",
  "http://server.com/secured/test1/doc_0_2.html");
System.out.println("Page Rank: " + entry.getGsaContent("pageRank"));
System.out.println("Collection List: " + entry.getGsaContent("collectionList"));
System.out.println("Forward Links: " + entry.getGsaContent("forwardLinks"));
System.out.println("Backward Links: " + entry.getGsaContent("backwardLinks"));
System.out.println("Is Cached: " + entry.getGsaContent("isCached"));
System.out.println("Document Date: " + entry.getGsaContent("date"));
System.out.println("Last Modified Date: " + entry.getGsaContent("lastModifiedDate"));
System.out.println("Latest Serving Version Timestamp: " +
  entry.getGsaContent("latestOnDisk"));
System.out.println("Currently In Process: " + entry.getGsaContent("currentlyInflight"));
System.out.println("Content Size: " + entry.getGsaContent("contentSize"));
System.out.println("Content Type: " + entry.getGsaContent("contentType"));
System.out.println("Crawl Frequency: " + entry.getGsaContent("crawlFrequency"));
System.out.println("Crawl History: " + entry.getGsaContent("crawlHistory"));

Content Statistics

Retrieve content statistics for each kind of document using the contentStatistics feed.

Common query parameters for all requests:

Content statistics entry properties:

Retrieving Content Statistics For All Crawled Files

Retrieve content statistics for all crawled files in a search appliance by sending an authenticated GET request to the root entry of the contentStatistics feed.

A list of content statistics entries are returned.

GsaFeed myFeed = myClient.getFeed("contentStatistics");
for(GsaEntry entry : myFeed.getEntries()) {
 System.out.println("Entry Name: " + entry.getGsaContent("entryID"));
 System.out.println("Maximum Size: " + entry.getGsaContent("maxSize"));
 System.out.println("Minimum Size: " + entry.getGsaContent("minSize"));
 System.out.println("Total Size: " + entry.getGsaContent("totalSize"));
 System.out.println("Average Size: " + entry.getGsaContent("avgSize"));
 System.out.println("Number of Files: " + entry.getGsaContent("numFiles"));
}

Retrieving Content Statistics For a Crawled File

Retrieve content statistics for a single crawled file by sending an authenticated GET request to a content statistics entry of the contentStatistics feed.

The following content statistics for a crawled file are returned:

GsaEntry entry = myClient.getEntry("contentStatistics", "text/html");
System.out.println("Maximum Size: " + entry.getGsaContent("maxSize"));
System.out.println("Minimum Size: " + entry.getGsaContent("minSize"));
System.out.println("Total Size: " + entry.getGsaContent("totalSize"));
System.out.println("Average Size: " + entry.getGsaContent("avgSize"));
System.out.println("Number of Files: " + entry.getGsaContent("numFiles"));

Search Reports

Generate, update, and delete search reports using the searchReport feed.

Search report entry properties:

Listing a Search Report

List search report entries by sending an authenticated GET request to the root entry of the searchReport feed. Query parameter:

A list of search report entries returns:

GsaFeed myFeed = myClient.getFeed("searchLog");
for(GsaEntry entry : myFeed.getEntries()) {
 System.out.println("Entry Name: " + entry.getGsaContent("entryID"));
 System.out.println("Report State: " + entry.getGsaContent("reportState"));
 System.out.println("Report Creation Date: " + entry.getGsaContent("reportCreationDate"));
 System.out.println("Report Date: " + entry.getGsaContent("reportDate"));
 System.out.println("Is Final: " + entry.getGsaContent("isFinal"));
 System.out.println("With Results: " + entry.getGsaContent("withResults"));
 System.out.println("Top Count: " + entry.getGsaContent("topCount"));
 System.out.println("Diagnostic Terms: " + entry.getGsaContent("diagnosticTerms"));
}

Creating a Search Report

Create a new search report entry by sending an authenticated POST request to the root entry of the searchReport feed.

The possible date formats for reports are as follows.

For example to specify the range of dates from 2 January 2009 to 23 September 2009, use this statement:

insertEntry.addGsaContent("reportDate", "range_1_2_2009_9_23_2009"); 

The following example generates and returns a new search report entry:

GsaEntry insertEntry = new GsaEntry();
insertEntry.addGsaContent("reportName", "bbb");
insertEntry.addGsaContent("collectionName", "default_collection");
insertEntry.addGsaContent("reportDate", "month_5_2009");

insertEntry.addGsaContent("withResults", "true");
insertEntry.addGsaContent("topCount", "100");

myClient.insertEntry("searchReport", insertEntry);

Retrieving a Search Report

Retrieve the search report status and get search log content by sending an authenticated GET request to a search report entry of the searchReport feed.

A search report entry with log content (if content is ready) is returned:

GsaEntry entry = myClient.getEntry("searchReport", "bbb@default_collection");
System.out.println("Entry Name: " + entry.getGsaContent("entryID"));
System.out.println("Report State: " + entry.getGsaContent("reportState"));
System.out.println("Report Creation Date: " + entry.getGsaContent("reportCreationDate"));
System.out.println("Report Date: " + entry.getGsaContent("reportDate"));
System.out.println("Is Final: " + entry.getGsaContent("isFinal"));
System.out.println("With Results: " + entry.getGsaContent("withResults"));
System.out.println("Top Count: " + entry.getGsaContent("topCount"));
System.out.println("Diagnostic Terms: " + entry.getGsaContent("diagnosticTerms"));

status = entry.getGsaContent("reportState");
if (status.equals("2") || status.equals("3")) {
 System.out.println("Report Content: " + entry.getGsaContent("reportContent"));
}

Updating a Search Report

Update the search report status and get search report content by sending an authenticated PUT request to a search report entry of the searchReport feed. There are no properties.

A search log entry is returned:

GsaEntry updateEntry = new GsaEntry();
myClient.updateEntry("searchReport","bbb@default_collection");

Deleting a Search Report

Delete a search report by sending an authenticated DELETE request to a search report entry of the searchReport feed.

The search report entry will be deleted:

myClient.deleteEntry("searchReport", "bbb@default_collection");

Search Logs

Generate, update, and delete a search log using the searchLog feed. A search log lists all search queries for a specified time frame in a format similar to a common log format (CLF).

Search log entry properties:

Listing a Search Log

List search log entries by sending an authenticated GET request to the root entry of the searchLog feed.

A list of search log entries will be returned.

GsaFeed myFeed = myClient.getFeed("searchLog");
for(GsaEntry entry : myFeed.getEntries()) {
 System.out.println("Entry Name: " + entry.getGsaContent("entryID"));
 System.out.println("Report State: " + entry.getGsaContent("reportState"));
 System.out.println("Report Creation Date: " + entry.getGsaContent("reportCreationDate"));
 System.out.println("Report Date: " + entry.getGsaContent("reportDate"));
 System.out.println("Is Final: " + entry.getGsaContent("isFinal"));
}

Creating a Search Log

Create a new search log entry by sending an authenticated POST request to the root entry of the searchLog feed.

A new search log entry will be generated and returned.

GsaEntry insertEntry = new GsaEntry();
insertEntry.addGsaContent("reportName", "bbb");
insertEntry.addGsaContent("collectionName", "default_collection");
insertEntry.addGsaContent("reportDate", "date_3_25_2009");

myClient.insertEntry("searchLog", insertEntry);

Retrieving a Search Log

Check the search log status and get search log content by sending an authenticated GET request to the search log entry of the searchLog feed using the following query parameters.

A search log entry with logContent, if content is ready, is returned.

Map<String, String> queries = new HashMap<String, String>();
queries.put("query","User");
queries.put("startLine","1");
queries.put("maxLine","10");

GsaEntry entry = myClient.queryEntry("searchLog", "bbb@default_collection", queries);
System.out.println("Entry Name: " + entry.getGsaContent("entryID"));
System.out.println("Report State: " + entry.getGsaContent("reportState"));
System.out.println("Report Creation Date: " + entry.getGsaContent("reportCreationDate"));
System.out.println("Report Date: " + entry.getGsaContent("reportDate"));
System.out.println("Is Final: " + entry.getGsaContent("isFinal"));
status = entry.getGsaContent("reportState");
if (status.equals("2") || status.equals("3")) {
 System.out.println("Log Content: " + entry.getGsaContent("logContent"));
 System.out.println("To Line: " + entry.getGsaContent("toLine"));
 System.out.println("From Line: " + entry.getGsaContent("fromLine"));
 System.out.println("Total Lines: " + entry.getGsaContent("totalLines"));
 }

Updating a Search Log

Update the search log status and get search log content by sending an authenticated PUT request to the search log entry of the searchLog feed. No properties are required.

GsaEntry updateEntry = new GsaEntry();
myClient.updateEntry("searchLog","bbb@default_collection");

Deleting a Search Log

Update the search log status and get search log content by sending an authenticated DELETE request to a search log entry of the searchLog feed.

The search log entry will be deleted.

myClient.deleteEntry("searchLog", "bbb@default_collection");

Event Log

Retrieve lines from the event log for a search appliance by using the eventLog entry of the logs feed. The following parameters let you make a query, specify a starting line, and specify the number of event log statements to retrieve.

Map<String, String> queries = new HashMap<String, String>();
queries.put("query","User");
queries.put("startLine","10");
queries.put("maxLine","2");
GsaEntry myEntry = myClient.queryEntry("logs", "eventLog", queries);
System.out.println("Log Content: " + myEntry.getGsaContent("logContent"));
System.out.println("Total Lines: " + myEntry.getGsaContent("totalLines"));
System.out.println("From Line: " + myEntry.getGsaContent("fromLine"));
System.out.println("To Line: " + myEntry.getGsaContent("toLine"));

// Create an entry to hold properties to insert
GsaEntry insertEntry = new GsaEntry();

// Add property for insertEntry
insertEntry.addGsaContent("entryID", "ConnectorManagerOne");
insertEntry.addGsaContent("description", "Connector Manager One Description");
insertEntry.addGsaContent("url", "http://example.com:port/");

// Send the request
myClient.insertEntry("connectorManager", insertEntry);

// Send the request and print the response
GsaFeed myFeed = myClient.getFeed("connectorManager");

for(GsaEntry myEntry : myFeed.getEntries()) {
  System.out.println("Status: " + myEntry.getGsaContent("status"));
  System.out.println("Description: " + myEntry.getGsaContent("description"));
  System.out.println("URL: " + myEntry.getGsaContent("url"));
}

// Send the request and print the response
GsaEntry myEntry = myClient.getEntry("connectorManager", "ConnectorManagerOne");
System.out.println("Status: " + myEntry.getGsaContent("status"));
System.out.println("Description: " + myEntry.getGsaContent("description"));
System.out.println("URL: " + myEntry.getGsaContent("url"));

// Create an entry to hold the properties to update
GsaEntry updateEntry = new GsaEntry();
updateEntry.setId(entryUrl);


// Add properties to updateEntry
updateEntry.addGsaContent("description", "new description");
updateEntry.addGsaContent("url", "#new URL");

// Send the request
myClient.updateEntry("connectorManager", "ConnectorManagerOne", updateEntry);

myClient.deleteEntry("connectorManager", "ConnectorManagerOne");

// Create an entry to hold properties to insert
GsaEntry insertEntry = new GsaEntry();
insertEntry.setId(entryUrl);


// In the following example code, add a secondary 
// node with arbitrary values for the various settings.
// Add properties to insertEntry
insertEntry.addGsaContent("entryID", "node_appliance_id");
insertEntry.addGsaContent("nodeType", "SECONDARY");
insertEntry.addGsaContent("federationNetworkIP", "10.0.0.2");
insertEntry.addGsaContent("secretToken", "token");
insertEntry.addGsaContent("hostname", "corp.domain.x.com");
insertEntry.addGsaContent("scoringBias", "20");

// Send the request
myClient.insertEntry("federation", insertEntry);

// Send a request and print the response
GsaEntry myEntry = myClient.getEntry("federation", "applianceId");
String type = myEntry.getGsaContent("nodeType");
System.out.println("Node Type: " + type);
System.out.println("Federation Network IP: " + myEntry.getGsaContent("federationNetworkIP"));
System.out.println("Host Name: " + myEntry.getGsaContent("hostname"));
System.out.println("Secret Token: " + myEntry.getGsaContent("secretToken"));
System.out.println("Scoring Bias: " + myEntry.getGsaContent("scoringBias"));

if (type.equals("SECONDARY")) {
  System.out.println("Remote Front End: " + myEntry.getGsaContent("remoteFrontend"));
  System.out.println("Node Timeout: " + myEntry.getGsaContent("slaveTimeout"));
}

if (type.equals("PRIMARY") || type.equals("PRIMARY_AND_SECONDARY")) {
  System.out.println("Secondary Nodes: " + myEntry.getGsaContent("secondaryNodes"));
}

// Send the request and print the response
GsaFeed myFeed = myClient.getFeed("federation");

for (GsaEntry gsaEntry : myFeed.getEntries()) {
  // Process each entry
}

// Create an entry to hold properties to update
GsaEntry updateEntry = new GsaEntry();
updateEntry.setId(entryUrl);


// Add properties to updateEntry
updateEntry.addGsaContent("entryID", "applianceId");
updateEntry.addGsaContent("nodeType", "PRIMARY");
updateEntry.addGsaContent("federationNetworkIP", "10.0.0.3");
updateEntry.addGsaContent("secretToken", "new_secret_token");
updateEntry.addGsaContent("hostname", "new_hostname");
updateEntry.addGsaContent("scoringBias", "20");

// Send the request
myClient.updateEntry("federation", "applianceId", updateEntry);

myClient.deleteEntry("federation", "applianceId");

// Send the request and print the response
GsaEntry myEntry = myClient.getEntry("info", "licenseInfo");
System.out.println("Appliance ID: " + myEntry.getGsaContent("applianceID"));
System.out.println("License ID: " + myEntry.getGsaContent("licenseID"));
System.out.println("License Valid Until: " + myEntry.getGsaContent("licenseValidUntil"));
System.out.println("Maximum Front Ends: " + myEntry.getGsaContent("maxFrontends"));
System.out.println("Maximum Pages: " + myEntry.getGsaContent("maxPages"));
System.out.println("Maximum Collections: " + myEntry.getGsaContent("maxCollections"));

// Send the request and print the response
GsaEntry myEntry = myClient.getEntry("command", "resetIndex");
System.out.println("Reset Index: " + myEntry.getGsaContent("resetIndex"));
System.out.println("Reset Status Code: " + myEntry.getGsaContent("resetStatusCode"));
System.out.println("Reset Status Message: " + myEntry.getGsaContent("resetStatusMessage"));

// Create an entry to hold properties to update
GsaEntry updateEntry = new GsaEntry();
    
// Add a property to updateEntry
updateEntry.addGsaContent("resetIndex", "1");
myClient.updateEntry("command", "resetIndex", updateEntry);

Map<String, String> queries = new HashMap<String, String>();
queries.put("password","12345678");

GsaEntry entry = myClient.queryEntry("config", "importExport");
System.out.println("XML Data: " + entry.getGsaContent("xmlData"));

GsaEntry updateEntry = new GsaEntry();
updateEntry.addGsaContent("xmlData", "<config data>");
updateEntry.addGsaContent("password", "12345678");

myClient.updateEntry("config", "importExport", updateEntry);

// Create an entry to hold properties to update
GsaEntry updateEntry = new GsaEntry();


// Add a property to updateEntry
updateEntry.addGsaContent("command", "reboot");

myClient.updateEntry("command", "shutdown", updateEntry);