src/main/java/com/gitblit/utils/FederationUtils.java - gitblit - Git at Google

 /*
  * Copyright 2011 gitblit.com.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *     http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 package com.gitblit.utils;

 import java.lang.reflect.Type;
 import java.text.MessageFormat;
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Collections;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;

 import javax.servlet.http.HttpServletResponse;

 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;

 import com.gitblit.Constants;
 import com.gitblit.Constants.FederationProposalResult;
 import com.gitblit.Constants.FederationRequest;
 import com.gitblit.Constants.FederationToken;
 import com.gitblit.IStoredSettings;
 import com.gitblit.Keys;
 import com.gitblit.models.FederationModel;
 import com.gitblit.models.FederationProposal;
 import com.gitblit.models.RepositoryModel;
 import com.gitblit.models.TeamModel;
 import com.gitblit.models.UserModel;
 import com.google.gson.reflect.TypeToken;

 /**
  * Utility methods for federation functions.
  *
  * @author James Moger
  *
  */
 public class FederationUtils {

 	private static final Type REPOSITORIES_TYPE = new TypeToken<Map<String, RepositoryModel>>() {
 	}.getType();

 	private static final Type SETTINGS_TYPE = new TypeToken<Map<String, String>>() {
 	}.getType();

 	private static final Type USERS_TYPE = new TypeToken<Collection<UserModel>>() {
 	}.getType();

 	private static final Type TEAMS_TYPE = new TypeToken<Collection<TeamModel>>() {
 	}.getType();

 	private static final Logger LOGGER = LoggerFactory.getLogger(FederationUtils.class);

 	/**
 	 * Returns an url to this servlet for the specified parameters.
 	 *
 	 * @param sourceURL
 	 *            the url of the source gitblit instance
 	 * @param token
 	 *            the federation token of the source gitblit instance
 	 * @param req
 	 *            the pull type request
 	 */
 	public static String asLink(String sourceURL, String token, FederationRequest req) {
 		return asLink(sourceURL, null, token, req, null);
 	}

 	/**
 	 *
 	 * @param remoteURL
 	 *            the url of the remote gitblit instance
 	 * @param tokenType
 	 *            the type of federation token of a gitblit instance
 	 * @param token
 	 *            the federation token of a gitblit instance
 	 * @param req
 	 *            the pull type request
 	 * @param myURL
 	 *            the url of this gitblit instance
 	 * @return
 	 */
 	public static String asLink(String remoteURL, FederationToken tokenType, String token,
 			FederationRequest req, String myURL) {
 		if (remoteURL.length() > 0 && remoteURL.charAt(remoteURL.length() - 1) == '/') {
 			remoteURL = remoteURL.substring(0, remoteURL.length() - 1);
 		}
 		if (req == null) {
 			req = FederationRequest.PULL_REPOSITORIES;
 		}
 		return remoteURL + Constants.FEDERATION_PATH + "?req=" + req.name().toLowerCase()
 				+ (token == null ? "" : ("&token=" + token))
 				+ (tokenType == null ? "" : ("&tokenType=" + tokenType.name().toLowerCase()))
 				+ (myURL == null ? "" : ("&url=" + StringUtils.encodeURL(myURL)));
 	}

 	/**
 	 * Returns the list of federated gitblit instances that this instance will
 	 * try to pull.
 	 *
 	 * @return list of registered gitblit instances
 	 */
 	public static List<FederationModel> getFederationRegistrations(IStoredSettings settings) {
 		List<FederationModel> federationRegistrations = new ArrayList<FederationModel>();
 		List<String> keys = settings.getAllKeys(Keys.federation._ROOT);
 		keys.remove(Keys.federation.name);
 		keys.remove(Keys.federation.passphrase);
 		keys.remove(Keys.federation.allowProposals);
 		keys.remove(Keys.federation.proposalsFolder);
 		keys.remove(Keys.federation.defaultFrequency);
 		keys.remove(Keys.federation.sets);
 		Collections.sort(keys);
 		Map<String, FederationModel> federatedModels = new HashMap<String, FederationModel>();
 		for (String key : keys) {
 			String value = key.substring(Keys.federation._ROOT.length() + 1);
 			List<String> values = StringUtils.getStringsFromValue(value, "\\.");
 			String server = values.get(0);
 			if (!federatedModels.containsKey(server)) {
 				federatedModels.put(server, new FederationModel(server));
 			}
 			String setting = values.get(1);
 			if (setting.equals("url")) {
 				// url of the origin Gitblit instance
 				federatedModels.get(server).url = settings.getString(key, "");
 			} else if (setting.equals("token")) {
 				// token for the origin Gitblit instance
 				federatedModels.get(server).token = settings.getString(key, "");
 			} else if (setting.equals("frequency")) {
 				// frequency of the pull operation
 				federatedModels.get(server).frequency = settings.getString(key, "");
 			} else if (setting.equals("folder")) {
 				// destination folder of the pull operation
 				federatedModels.get(server).folder = settings.getString(key, "");
 			} else if (setting.equals("bare")) {
 				// whether pulled repositories should be bare
 				federatedModels.get(server).bare = settings.getBoolean(key, true);
 			} else if (setting.equals("mirror")) {
 				// are the repositories to be true mirrors of the origin
 				federatedModels.get(server).mirror = settings.getBoolean(key, true);
 			} else if (setting.equals("mergeAccounts")) {
 				// merge remote accounts into local accounts
 				federatedModels.get(server).mergeAccounts = settings.getBoolean(key, false);
 			} else if (setting.equals("sendStatus")) {
 				// send a status acknowledgment to source Gitblit instance
 				// at end of git pull
 				federatedModels.get(server).sendStatus = settings.getBoolean(key, false);
 			} else if (setting.equals("notifyOnError")) {
 				// notify administrators on federation pull failures
 				federatedModels.get(server).notifyOnError = settings.getBoolean(key, false);
 			} else if (setting.equals("exclude")) {
 				// excluded repositories
 				federatedModels.get(server).exclusions = settings.getStrings(key);
 			} else if (setting.equals("include")) {
 				// included repositories
 				federatedModels.get(server).inclusions = settings.getStrings(key);
 			}
 		}

 		// verify that registrations have a url and a token
 		for (FederationModel model : federatedModels.values()) {
 			if (StringUtils.isEmpty(model.url)) {
 				LOGGER.warn(MessageFormat.format(
 						"Dropping federation registration {0}. Missing url.", model.name));
 				continue;
 			}
 			if (StringUtils.isEmpty(model.token)) {
 				LOGGER.warn(MessageFormat.format(
 						"Dropping federation registration {0}. Missing token.", model.name));
 				continue;
 			}
 			// set default frequency if unspecified
 			if (StringUtils.isEmpty(model.frequency)) {
 				model.frequency = settings.getString(Keys.federation.defaultFrequency, "60 mins");
 			}
 			federationRegistrations.add(model);
 		}
 		return federationRegistrations;
 	}

 	/**
 	 * Sends a federation poke to the Gitblit instance at remoteUrl. Pokes are
 	 * sent by an pulling Gitblit instance to an origin Gitblit instance as part
 	 * of the proposal process. This is to ensure that the pulling Gitblit
 	 * instance has an IP route to the origin instance.
 	 *
 	 * @param remoteUrl
 	 *            the remote Gitblit instance to send a federation proposal to
 	 * @param proposal
 	 *            a complete federation proposal
 	 * @return true if there is a route to the remoteUrl
 	 */
 	public static boolean poke(String remoteUrl) throws Exception {
 		String url = asLink(remoteUrl, null, FederationRequest.POKE);
 		String json = JsonUtils.toJsonString("POKE");
 		int status = JsonUtils.sendJsonString(url, json);
 		return status == HttpServletResponse.SC_OK;
 	}

 	/**
 	 * Sends a federation proposal to the Gitblit instance at remoteUrl
 	 *
 	 * @param remoteUrl
 	 *            the remote Gitblit instance to send a federation proposal to
 	 * @param proposal
 	 *            a complete federation proposal
 	 * @return the federation proposal result code
 	 */
 	public static FederationProposalResult propose(String remoteUrl, FederationProposal proposal)
 			throws Exception {
 		String url = asLink(remoteUrl, null, FederationRequest.PROPOSAL);
 		String json = JsonUtils.toJsonString(proposal);
 		int status = JsonUtils.sendJsonString(url, json);
 		switch (status) {
 		case HttpServletResponse.SC_FORBIDDEN:
 			// remote Gitblit Federation disabled
 			return FederationProposalResult.FEDERATION_DISABLED;
 		case HttpServletResponse.SC_BAD_REQUEST:
 			// remote Gitblit did not receive any JSON data
 			return FederationProposalResult.MISSING_DATA;
 		case HttpServletResponse.SC_METHOD_NOT_ALLOWED:
 			// remote Gitblit not accepting proposals
 			return FederationProposalResult.NO_PROPOSALS;
 		case HttpServletResponse.SC_NOT_ACCEPTABLE:
 			// remote Gitblit failed to poke this Gitblit instance
 			return FederationProposalResult.NO_POKE;
 		case HttpServletResponse.SC_OK:
 			// received
 			return FederationProposalResult.ACCEPTED;
 		default:
 			return FederationProposalResult.ERROR;
 		}
 	}

 	/**
 	 * Retrieves a map of the repositories at the remote gitblit instance keyed
 	 * by the repository clone url.
 	 *
 	 * @param registration
 	 * @param checkExclusions
 	 *            should returned repositories remove registration exclusions
 	 * @return a map of cloneable repositories
 	 * @throws Exception
 	 */
 	public static Map<String, RepositoryModel> getRepositories(FederationModel registration,
 			boolean checkExclusions) throws Exception {
 		String url = asLink(registration.url, registration.token,
 				FederationRequest.PULL_REPOSITORIES);
 		Map<String, RepositoryModel> models = JsonUtils.retrieveJson(url, REPOSITORIES_TYPE);
 		if (checkExclusions) {
 			Map<String, RepositoryModel> includedModels = new HashMap<String, RepositoryModel>();
 			for (Map.Entry<String, RepositoryModel> entry : models.entrySet()) {
 				if (registration.isIncluded(entry.getValue())) {
 					includedModels.put(entry.getKey(), entry.getValue());
 				}
 			}
 			return includedModels;
 		}
 		return models;
 	}

 	/**
 	 * Tries to pull the gitblit user accounts from the remote gitblit instance.
 	 *
 	 * @param registration
 	 * @return a collection of UserModel objects
 	 * @throws Exception
 	 */
 	public static List<UserModel> getUsers(FederationModel registration) throws Exception {
 		String url = asLink(registration.url, registration.token, FederationRequest.PULL_USERS);
 		Collection<UserModel> models = JsonUtils.retrieveJson(url, USERS_TYPE);
 		List<UserModel> list = new ArrayList<UserModel>(models);
 		return list;
 	}

 	/**
 	 * Tries to pull the gitblit team definitions from the remote gitblit
 	 * instance.
 	 *
 	 * @param registration
 	 * @return a collection of TeamModel objects
 	 * @throws Exception
 	 */
 	public static List<TeamModel> getTeams(FederationModel registration) throws Exception {
 		String url = asLink(registration.url, registration.token, FederationRequest.PULL_TEAMS);
 		Collection<TeamModel> models = JsonUtils.retrieveJson(url, TEAMS_TYPE);
 		List<TeamModel> list = new ArrayList<TeamModel>(models);
 		return list;
 	}

 	/**
 	 * Tries to pull the gitblit server settings from the remote gitblit
 	 * instance.
 	 *
 	 * @param registration
 	 * @return a map of the remote gitblit settings
 	 * @throws Exception
 	 */
 	public static Map<String, String> getSettings(FederationModel registration) throws Exception {
 		String url = asLink(registration.url, registration.token, FederationRequest.PULL_SETTINGS);
 		Map<String, String> settings = JsonUtils.retrieveJson(url, SETTINGS_TYPE);
 		return settings;
 	}

 	/**
 	 * Tries to pull the referenced scripts from the remote gitblit instance.
 	 *
 	 * @param registration
 	 * @return a map of the remote gitblit scripts by script name
 	 * @throws Exception
 	 */
 	public static Map<String, String> getScripts(FederationModel registration) throws Exception {
 		String url = asLink(registration.url, registration.token, FederationRequest.PULL_SCRIPTS);
 		Map<String, String> scripts = JsonUtils.retrieveJson(url, SETTINGS_TYPE);
 		return scripts;
 	}

 	/**
 	 * Send an status acknowledgment to the remote Gitblit server.
 	 *
 	 * @param identification
 	 *            identification of this pulling instance
 	 * @param registration
 	 *            the source Gitblit instance to receive an acknowledgment
 	 * @param results
 	 *            the results of your pull operation
 	 * @return true, if the remote Gitblit instance acknowledged your results
 	 * @throws Exception
 	 */
 	public static boolean acknowledgeStatus(String identification, FederationModel registration)
 			throws Exception {
 		String url = asLink(registration.url, null, registration.token, FederationRequest.STATUS,
 				identification);
 		String json = JsonUtils.toJsonString(registration);
 		int status = JsonUtils.sendJsonString(url, json);
 		return status == HttpServletResponse.SC_OK;
 	}
 }
	/*
	* Copyright 2011 gitblit.com.
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/
	package com.gitblit.utils;

	import java.lang.reflect.Type;
	import java.text.MessageFormat;
	import java.util.ArrayList;
	import java.util.Collection;
	import java.util.Collections;
	import java.util.HashMap;
	import java.util.List;
	import java.util.Map;

	import javax.servlet.http.HttpServletResponse;

	import org.slf4j.Logger;
	import org.slf4j.LoggerFactory;

	import com.gitblit.Constants;
	import com.gitblit.Constants.FederationProposalResult;
	import com.gitblit.Constants.FederationRequest;
	import com.gitblit.Constants.FederationToken;
	import com.gitblit.IStoredSettings;
	import com.gitblit.Keys;
	import com.gitblit.models.FederationModel;
	import com.gitblit.models.FederationProposal;
	import com.gitblit.models.RepositoryModel;
	import com.gitblit.models.TeamModel;
	import com.gitblit.models.UserModel;
	import com.google.gson.reflect.TypeToken;

	/**
	* Utility methods for federation functions.
	*
	* @author James Moger
	*
	*/
	public class FederationUtils {

	private static final Type REPOSITORIES_TYPE = new TypeToken<Map<String, RepositoryModel>>() {
	}.getType();

	private static final Type SETTINGS_TYPE = new TypeToken<Map<String, String>>() {
	}.getType();

	private static final Type USERS_TYPE = new TypeToken<Collection<UserModel>>() {
	}.getType();

	private static final Type TEAMS_TYPE = new TypeToken<Collection<TeamModel>>() {
	}.getType();

	private static final Logger LOGGER = LoggerFactory.getLogger(FederationUtils.class);

	/**
	* Returns an url to this servlet for the specified parameters.
	*
	* @param sourceURL
	* the url of the source gitblit instance
	* @param token
	* the federation token of the source gitblit instance
	* @param req
	* the pull type request
	*/
	public static String asLink(String sourceURL, String token, FederationRequest req) {
	return asLink(sourceURL, null, token, req, null);
	}

	/**
	*
	* @param remoteURL
	* the url of the remote gitblit instance
	* @param tokenType
	* the type of federation token of a gitblit instance
	* @param token
	* the federation token of a gitblit instance
	* @param req
	* the pull type request
	* @param myURL
	* the url of this gitblit instance
	* @return
	*/
	public static String asLink(String remoteURL, FederationToken tokenType, String token,
	FederationRequest req, String myURL) {
	if (remoteURL.length() > 0 && remoteURL.charAt(remoteURL.length() - 1) == '/') {
	remoteURL = remoteURL.substring(0, remoteURL.length() - 1);
	}
	if (req == null) {
	req = FederationRequest.PULL_REPOSITORIES;
	}
	return remoteURL + Constants.FEDERATION_PATH + "?req=" + req.name().toLowerCase()
	+ (token == null ? "" : ("&token=" + token))
	+ (tokenType == null ? "" : ("&tokenType=" + tokenType.name().toLowerCase()))
	+ (myURL == null ? "" : ("&url=" + StringUtils.encodeURL(myURL)));
	}

	/**
	* Returns the list of federated gitblit instances that this instance will
	* try to pull.
	*
	* @return list of registered gitblit instances
	*/
	public static List<FederationModel> getFederationRegistrations(IStoredSettings settings) {
	List<FederationModel> federationRegistrations = new ArrayList<FederationModel>();
	List<String> keys = settings.getAllKeys(Keys.federation._ROOT);
	keys.remove(Keys.federation.name);
	keys.remove(Keys.federation.passphrase);
	keys.remove(Keys.federation.allowProposals);
	keys.remove(Keys.federation.proposalsFolder);
	keys.remove(Keys.federation.defaultFrequency);
	keys.remove(Keys.federation.sets);
	Collections.sort(keys);
	Map<String, FederationModel> federatedModels = new HashMap<String, FederationModel>();
	for (String key : keys) {
	String value = key.substring(Keys.federation._ROOT.length() + 1);
	List<String> values = StringUtils.getStringsFromValue(value, "\\.");
	String server = values.get(0);
	if (!federatedModels.containsKey(server)) {
	federatedModels.put(server, new FederationModel(server));
	}
	String setting = values.get(1);
	if (setting.equals("url")) {
	// url of the origin Gitblit instance
	federatedModels.get(server).url = settings.getString(key, "");
	} else if (setting.equals("token")) {
	// token for the origin Gitblit instance
	federatedModels.get(server).token = settings.getString(key, "");
	} else if (setting.equals("frequency")) {
	// frequency of the pull operation
	federatedModels.get(server).frequency = settings.getString(key, "");
	} else if (setting.equals("folder")) {
	// destination folder of the pull operation
	federatedModels.get(server).folder = settings.getString(key, "");
	} else if (setting.equals("bare")) {
	// whether pulled repositories should be bare
	federatedModels.get(server).bare = settings.getBoolean(key, true);
	} else if (setting.equals("mirror")) {
	// are the repositories to be true mirrors of the origin
	federatedModels.get(server).mirror = settings.getBoolean(key, true);
	} else if (setting.equals("mergeAccounts")) {
	// merge remote accounts into local accounts
	federatedModels.get(server).mergeAccounts = settings.getBoolean(key, false);
	} else if (setting.equals("sendStatus")) {
	// send a status acknowledgment to source Gitblit instance
	// at end of git pull
	federatedModels.get(server).sendStatus = settings.getBoolean(key, false);
	} else if (setting.equals("notifyOnError")) {
	// notify administrators on federation pull failures
	federatedModels.get(server).notifyOnError = settings.getBoolean(key, false);
	} else if (setting.equals("exclude")) {
	// excluded repositories
	federatedModels.get(server).exclusions = settings.getStrings(key);
	} else if (setting.equals("include")) {
	// included repositories
	federatedModels.get(server).inclusions = settings.getStrings(key);
	}
	}

	// verify that registrations have a url and a token
	for (FederationModel model : federatedModels.values()) {
	if (StringUtils.isEmpty(model.url)) {
	LOGGER.warn(MessageFormat.format(
	"Dropping federation registration {0}. Missing url.", model.name));
	continue;
	}
	if (StringUtils.isEmpty(model.token)) {
	LOGGER.warn(MessageFormat.format(
	"Dropping federation registration {0}. Missing token.", model.name));
	continue;
	}
	// set default frequency if unspecified
	if (StringUtils.isEmpty(model.frequency)) {
	model.frequency = settings.getString(Keys.federation.defaultFrequency, "60 mins");
	}
	federationRegistrations.add(model);
	}
	return federationRegistrations;
	}

	/**
	* Sends a federation poke to the Gitblit instance at remoteUrl. Pokes are
	* sent by an pulling Gitblit instance to an origin Gitblit instance as part
	* of the proposal process. This is to ensure that the pulling Gitblit
	* instance has an IP route to the origin instance.
	*
	* @param remoteUrl
	* the remote Gitblit instance to send a federation proposal to
	* @param proposal
	* a complete federation proposal
	* @return true if there is a route to the remoteUrl
	*/
	public static boolean poke(String remoteUrl) throws Exception {
	String url = asLink(remoteUrl, null, FederationRequest.POKE);
	String json = JsonUtils.toJsonString("POKE");
	int status = JsonUtils.sendJsonString(url, json);
	return status == HttpServletResponse.SC_OK;
	}

	/**
	* Sends a federation proposal to the Gitblit instance at remoteUrl
	*
	* @param remoteUrl
	* the remote Gitblit instance to send a federation proposal to
	* @param proposal
	* a complete federation proposal
	* @return the federation proposal result code
	*/
	public static FederationProposalResult propose(String remoteUrl, FederationProposal proposal)
	throws Exception {
	String url = asLink(remoteUrl, null, FederationRequest.PROPOSAL);
	String json = JsonUtils.toJsonString(proposal);
	int status = JsonUtils.sendJsonString(url, json);
	switch (status) {
	case HttpServletResponse.SC_FORBIDDEN:
	// remote Gitblit Federation disabled
	return FederationProposalResult.FEDERATION_DISABLED;
	case HttpServletResponse.SC_BAD_REQUEST:
	// remote Gitblit did not receive any JSON data
	return FederationProposalResult.MISSING_DATA;
	case HttpServletResponse.SC_METHOD_NOT_ALLOWED:
	// remote Gitblit not accepting proposals
	return FederationProposalResult.NO_PROPOSALS;
	case HttpServletResponse.SC_NOT_ACCEPTABLE:
	// remote Gitblit failed to poke this Gitblit instance
	return FederationProposalResult.NO_POKE;
	case HttpServletResponse.SC_OK:
	// received
	return FederationProposalResult.ACCEPTED;
	default:
	return FederationProposalResult.ERROR;
	}
	}

	/**
	* Retrieves a map of the repositories at the remote gitblit instance keyed
	* by the repository clone url.
	*
	* @param registration
	* @param checkExclusions
	* should returned repositories remove registration exclusions
	* @return a map of cloneable repositories
	* @throws Exception
	*/
	public static Map<String, RepositoryModel> getRepositories(FederationModel registration,
	boolean checkExclusions) throws Exception {
	String url = asLink(registration.url, registration.token,
	FederationRequest.PULL_REPOSITORIES);
	Map<String, RepositoryModel> models = JsonUtils.retrieveJson(url, REPOSITORIES_TYPE);
	if (checkExclusions) {
	Map<String, RepositoryModel> includedModels = new HashMap<String, RepositoryModel>();
	for (Map.Entry<String, RepositoryModel> entry : models.entrySet()) {
	if (registration.isIncluded(entry.getValue())) {
	includedModels.put(entry.getKey(), entry.getValue());
	}
	}
	return includedModels;
	}
	return models;
	}

	/**
	* Tries to pull the gitblit user accounts from the remote gitblit instance.
	*
	* @param registration
	* @return a collection of UserModel objects
	* @throws Exception
	*/
	public static List<UserModel> getUsers(FederationModel registration) throws Exception {
	String url = asLink(registration.url, registration.token, FederationRequest.PULL_USERS);
	Collection<UserModel> models = JsonUtils.retrieveJson(url, USERS_TYPE);
	List<UserModel> list = new ArrayList<UserModel>(models);
	return list;
	}

	/**
	* Tries to pull the gitblit team definitions from the remote gitblit
	* instance.
	*
	* @param registration
	* @return a collection of TeamModel objects
	* @throws Exception
	*/
	public static List<TeamModel> getTeams(FederationModel registration) throws Exception {
	String url = asLink(registration.url, registration.token, FederationRequest.PULL_TEAMS);
	Collection<TeamModel> models = JsonUtils.retrieveJson(url, TEAMS_TYPE);
	List<TeamModel> list = new ArrayList<TeamModel>(models);
	return list;
	}

	/**
	* Tries to pull the gitblit server settings from the remote gitblit
	* instance.
	*
	* @param registration
	* @return a map of the remote gitblit settings
	* @throws Exception
	*/
	public static Map<String, String> getSettings(FederationModel registration) throws Exception {
	String url = asLink(registration.url, registration.token, FederationRequest.PULL_SETTINGS);
	Map<String, String> settings = JsonUtils.retrieveJson(url, SETTINGS_TYPE);
	return settings;
	}

	/**
	* Tries to pull the referenced scripts from the remote gitblit instance.
	*
	* @param registration
	* @return a map of the remote gitblit scripts by script name
	* @throws Exception
	*/
	public static Map<String, String> getScripts(FederationModel registration) throws Exception {
	String url = asLink(registration.url, registration.token, FederationRequest.PULL_SCRIPTS);
	Map<String, String> scripts = JsonUtils.retrieveJson(url, SETTINGS_TYPE);
	return scripts;
	}

	/**
	* Send an status acknowledgment to the remote Gitblit server.
	*
	* @param identification
	* identification of this pulling instance
	* @param registration
	* the source Gitblit instance to receive an acknowledgment
	* @param results
	* the results of your pull operation
	* @return true, if the remote Gitblit instance acknowledged your results
	* @throws Exception
	*/
	public static boolean acknowledgeStatus(String identification, FederationModel registration)
	throws Exception {
	String url = asLink(registration.url, null, registration.token, FederationRequest.STATUS,
	identification);
	String json = JsonUtils.toJsonString(registration);
	int status = JsonUtils.sendJsonString(url, json);
	return status == HttpServletResponse.SC_OK;
	}
	}