src/main/java/com/gitblit/tickets/FileTicketService.java - gitblit - Git at Google

 /*
  * Copyright 2014 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.tickets;

 import java.io.File;
 import java.io.IOException;
 import java.text.MessageFormat;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
 import java.util.TreeSet;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.atomic.AtomicLong;

 import org.eclipse.jgit.lib.Repository;

 import com.gitblit.Constants;
 import com.gitblit.manager.INotificationManager;
 import com.gitblit.manager.IPluginManager;
 import com.gitblit.manager.IRepositoryManager;
 import com.gitblit.manager.IRuntimeManager;
 import com.gitblit.manager.IUserManager;
 import com.gitblit.models.RepositoryModel;
 import com.gitblit.models.TicketModel;
 import com.gitblit.models.TicketModel.Attachment;
 import com.gitblit.models.TicketModel.Change;
 import com.gitblit.utils.ArrayUtils;
 import com.gitblit.utils.FileUtils;
 import com.gitblit.utils.StringUtils;
 import com.google.inject.Inject;
 import com.google.inject.Singleton;

 /**
  * Implementation of a ticket service based on a directory within the repository.
  * All tickets are serialized as a list of JSON changes and persisted in a hashed
  * directory structure, similar to the standard git loose object structure.
  *
  * @author James Moger
  *
  */
 @Singleton
 public class FileTicketService extends ITicketService {

 	private static final String JOURNAL = "journal.json";

 	private static final String TICKETS_PATH = "tickets/";

 	private final Map<String, AtomicLong> lastAssignedId;

 	@Inject
 	public FileTicketService(
 			IRuntimeManager runtimeManager,
 			IPluginManager pluginManager,
 			INotificationManager notificationManager,
 			IUserManager userManager,
 			IRepositoryManager repositoryManager) {

 		super(runtimeManager,
 				pluginManager,
 				notificationManager,
 				userManager,
 				repositoryManager);

 		lastAssignedId = new ConcurrentHashMap<String, AtomicLong>();
 	}

 	@Override
 	public void onStart() {
 		log.info("{} started", getClass().getSimpleName());
 	}

 	@Override
 	protected void resetCachesImpl() {
 		lastAssignedId.clear();
 	}

 	@Override
 	protected void resetCachesImpl(RepositoryModel repository) {
 		if (lastAssignedId.containsKey(repository.name)) {
 			lastAssignedId.get(repository.name).set(0);
 		}
 	}

 	@Override
 	protected void close() {
 	}

 	/**
 	 * Returns the ticket path. This follows the same scheme as Git's object
 	 * store path where the first two characters of the hash id are the root
 	 * folder with the remaining characters as a subfolder within that folder.
 	 *
 	 * @param ticketId
 	 * @return the root path of the ticket content in the ticket directory
 	 */
 	private String toTicketPath(long ticketId) {
 		StringBuilder sb = new StringBuilder();
 		sb.append(TICKETS_PATH);
 		long m = ticketId % 100L;
 		if (m < 10) {
 			sb.append('0');
 		}
 		sb.append(m);
 		sb.append('/');
 		sb.append(ticketId);
 		return sb.toString();
 	}

 	/**
 	 * Returns the path to the attachment for the specified ticket.
 	 *
 	 * @param ticketId
 	 * @param filename
 	 * @return the path to the specified attachment
 	 */
 	private String toAttachmentPath(long ticketId, String filename) {
 		return toTicketPath(ticketId) + "/attachments/" + filename;
 	}

 	/**
 	 * Ensures that we have a ticket for this ticket id.
 	 *
 	 * @param repository
 	 * @param ticketId
 	 * @return true if the ticket exists
 	 */
 	@Override
 	public boolean hasTicket(RepositoryModel repository, long ticketId) {
 		boolean hasTicket = false;
 		Repository db = repositoryManager.getRepository(repository.name);
 		try {
 			String journalPath = toTicketPath(ticketId) + "/" + JOURNAL;
 			hasTicket = new File(db.getDirectory(), journalPath).exists();
 		} finally {
 			db.close();
 		}
 		return hasTicket;
 	}

 	@Override
 	public synchronized Set<Long> getIds(RepositoryModel repository) {
 		Set<Long> ids = new TreeSet<Long>();
 		Repository db = repositoryManager.getRepository(repository.name);
 		try {
 			// identify current highest ticket id by scanning the paths in the tip tree
 			File dir = new File(db.getDirectory(), TICKETS_PATH);
 			dir.mkdirs();
 			List<File> journals = findAll(dir, JOURNAL);
 			for (File journal : journals) {
 				// Reconstruct ticketId from the path
 				// id/26/326/journal.json
 				String path = FileUtils.getRelativePath(dir, journal);
 				String tid = path.split("/")[1];
 				long ticketId = Long.parseLong(tid);
 				ids.add(ticketId);
 			}
 		} finally {
 			if (db != null) {
 				db.close();
 			}
 		}
 		return ids;
 	}

 	/**
 	 * Assigns a new ticket id.
 	 *
 	 * @param repository
 	 * @return a new long id
 	 */
 	@Override
 	public synchronized long assignNewId(RepositoryModel repository) {
 		long newId = 0L;
 		Repository db = repositoryManager.getRepository(repository.name);
 		try {
 			if (!lastAssignedId.containsKey(repository.name)) {
 				lastAssignedId.put(repository.name, new AtomicLong(0));
 			}
 			AtomicLong lastId = lastAssignedId.get(repository.name);
 			if (lastId.get() <= 0) {
 				Set<Long> ids = getIds(repository);
 				for (long id : ids) {
 					if (id > lastId.get()) {
 						lastId.set(id);
 					}
 				}
 			}

 			// assign the id and touch an empty journal to hold it's place
 			newId = lastId.incrementAndGet();
 			String journalPath = toTicketPath(newId) + "/" + JOURNAL;
 			File journal = new File(db.getDirectory(), journalPath);
 			journal.getParentFile().mkdirs();
 			journal.createNewFile();
 		} catch (IOException e) {
 			log.error("failed to assign ticket id", e);
 			return 0L;
 		} finally {
 			db.close();
 		}
 		return newId;
 	}

 	/**
 	 * Returns all the tickets in the repository. Querying tickets from the
 	 * repository requires deserializing all tickets. This is an  expensive
 	 * process and not recommended. Tickets are indexed by Lucene and queries
 	 * should be executed against that index.
 	 *
 	 * @param repository
 	 * @param filter
 	 *            optional filter to only return matching results
 	 * @return a list of tickets
 	 */
 	@Override
 	public List<TicketModel> getTickets(RepositoryModel repository, TicketFilter filter) {
 		List<TicketModel> list = new ArrayList<TicketModel>();

 		Repository db = repositoryManager.getRepository(repository.name);
 		try {
 			// Collect the set of all json files
 			File dir = new File(db.getDirectory(), TICKETS_PATH);
 			List<File> journals = findAll(dir, JOURNAL);

 			// Deserialize each ticket and optionally filter out unwanted tickets
 			for (File journal : journals) {
 				String json = null;
 				try {
 					json = new String(FileUtils.readContent(journal), Constants.ENCODING);
 				} catch (Exception e) {
 					log.error(null, e);
 				}
 				if (StringUtils.isEmpty(json)) {
 					// journal was touched but no changes were written
 					continue;
 				}
 				try {
 					// Reconstruct ticketId from the path
 					// id/26/326/journal.json
 					String path = FileUtils.getRelativePath(dir, journal);
 					String tid = path.split("/")[1];
 					long ticketId = Long.parseLong(tid);
 					List<Change> changes = TicketSerializer.deserializeJournal(json);
 					if (ArrayUtils.isEmpty(changes)) {
 						log.warn("Empty journal for {}:{}", repository, journal);
 						continue;
 					}
 					TicketModel ticket = TicketModel.buildTicket(changes);
 					ticket.project = repository.projectPath;
 					ticket.repository = repository.name;
 					ticket.number = ticketId;

 					// add the ticket, conditionally, to the list
 					if (filter == null) {
 						list.add(ticket);
 					} else {
 						if (filter.accept(ticket)) {
 							list.add(ticket);
 						}
 					}
 				} catch (Exception e) {
 					log.error("failed to deserialize {}/{}\n{}",
 							new Object [] { repository, journal, e.getMessage()});
 					log.error(null, e);
 				}
 			}

 			// sort the tickets by creation
 			Collections.sort(list);
 			return list;
 		} finally {
 			db.close();
 		}
 	}

 	private List<File> findAll(File dir, String filename) {
 		List<File> list = new ArrayList<File>();
 		File [] files = dir.listFiles();
 		if (files == null) {
 			return list;
 		}
 		for (File file : files) {
 			if (file.isDirectory()) {
 				list.addAll(findAll(file, filename));
 			} else if (file.isFile()) {
 				if (file.getName().equalsIgnoreCase(filename)) {
 					list.add(file);
 				}
 			}
 		}
 		return list;
 	}

 	/**
 	 * Retrieves the ticket from the repository.
 	 *
 	 * @param repository
 	 * @param ticketId
 	 * @return a ticket, if it exists, otherwise null
 	 */
 	@Override
 	protected TicketModel getTicketImpl(RepositoryModel repository, long ticketId) {
 		Repository db = repositoryManager.getRepository(repository.name);
 		try {
 			List<Change> changes = getJournal(db, ticketId);
 			if (ArrayUtils.isEmpty(changes)) {
 				log.warn("Empty journal for {}:{}", repository, ticketId);
 				return null;
 			}
 			TicketModel ticket = TicketModel.buildTicket(changes);
 			if (ticket != null) {
 				ticket.project = repository.projectPath;
 				ticket.repository = repository.name;
 				ticket.number = ticketId;
 			}
 			return ticket;
 		} finally {
 			db.close();
 		}
 	}

 	/**
 	 * Retrieves the journal for the ticket.
 	 *
 	 * @param repository
 	 * @param ticketId
 	 * @return a journal, if it exists, otherwise null
 	 */
 	@Override
 	protected List<Change> getJournalImpl(RepositoryModel repository, long ticketId) {
 		Repository db = repositoryManager.getRepository(repository.name);
 		try {
 			List<Change> changes = getJournal(db, ticketId);
 			if (ArrayUtils.isEmpty(changes)) {
 				log.warn("Empty journal for {}:{}", repository, ticketId);
 				return null;
 			}
 			return changes;
 		} finally {
 			db.close();
 		}
 	}

 	/**
 	 * Returns the journal for the specified ticket.
 	 *
 	 * @param db
 	 * @param ticketId
 	 * @return a list of changes
 	 */
 	private List<Change> getJournal(Repository db, long ticketId) {
 		if (ticketId <= 0L) {
 			return new ArrayList<Change>();
 		}

 		String journalPath = toTicketPath(ticketId) + "/" + JOURNAL;
 		File journal = new File(db.getDirectory(), journalPath);
 		if (!journal.exists()) {
 			return new ArrayList<Change>();
 		}

 		String json = null;
 		try {
 			json = new String(FileUtils.readContent(journal), Constants.ENCODING);
 		} catch (Exception e) {
 			log.error(null, e);
 		}
 		if (StringUtils.isEmpty(json)) {
 			return new ArrayList<Change>();
 		}
 		List<Change> list = TicketSerializer.deserializeJournal(json);
 		return list;
 	}

 	@Override
 	public boolean supportsAttachments() {
 		return true;
 	}

 	/**
 	 * Retrieves the specified attachment from a ticket.
 	 *
 	 * @param repository
 	 * @param ticketId
 	 * @param filename
 	 * @return an attachment, if found, null otherwise
 	 */
 	@Override
 	public Attachment getAttachment(RepositoryModel repository, long ticketId, String filename) {
 		if (ticketId <= 0L) {
 			return null;
 		}

 		// deserialize the ticket model so that we have the attachment metadata
 		TicketModel ticket = getTicket(repository, ticketId);
 		Attachment attachment = ticket.getAttachment(filename);

 		// attachment not found
 		if (attachment == null) {
 			return null;
 		}

 		// retrieve the attachment content
 		Repository db = repositoryManager.getRepository(repository.name);
 		try {
 			String attachmentPath = toAttachmentPath(ticketId, attachment.name);
 			File file = new File(db.getDirectory(), attachmentPath);
 			if (file.exists()) {
 				attachment.content = FileUtils.readContent(file);
 				attachment.size = attachment.content.length;
 			}
 			return attachment;
 		} finally {
 			db.close();
 		}
 	}

 	/**
 	 * Deletes a ticket from the repository.
 	 *
 	 * @param ticket
 	 * @return true if successful
 	 */
 	@Override
 	protected synchronized boolean deleteTicketImpl(RepositoryModel repository, TicketModel ticket, String deletedBy) {
 		if (ticket == null) {
 			throw new RuntimeException("must specify a ticket!");
 		}

 		boolean success = false;
 		Repository db = repositoryManager.getRepository(ticket.repository);
 		try {
 			String ticketPath = toTicketPath(ticket.number);
 			File dir = new File(db.getDirectory(), ticketPath);
 			if (dir.exists()) {
 				success = FileUtils.delete(dir);
 			}
 			success = true;
 		} finally {
 			db.close();
 		}
 		return success;
 	}

 	/**
 	 * Commit a ticket change to the repository.
 	 *
 	 * @param repository
 	 * @param ticketId
 	 * @param change
 	 * @return true, if the change was committed
 	 */
 	@Override
 	protected synchronized boolean commitChangeImpl(RepositoryModel repository, long ticketId, Change change) {
 		boolean success = false;

 		Repository db = repositoryManager.getRepository(repository.name);
 		try {
 			List<Change> changes = getJournal(db, ticketId);
 			changes.add(change);
 			String journal = TicketSerializer.serializeJournal(changes).trim();

 			String journalPath = toTicketPath(ticketId) + "/" + JOURNAL;
 			File file = new File(db.getDirectory(), journalPath);
 			file.getParentFile().mkdirs();
 			FileUtils.writeContent(file, journal);
 			success = true;
 		} catch (Throwable t) {
 			log.error(MessageFormat.format("Failed to commit ticket {0,number,0} to {1}",
 					ticketId, db.getDirectory()), t);
 		} finally {
 			db.close();
 		}
 		return success;
 	}

 	@Override
 	protected boolean deleteAllImpl(RepositoryModel repository) {
 		Repository db = repositoryManager.getRepository(repository.name);
 		if (db == null) {
 			// the tickets no longer exist because the db no longer exists
 			return true;
 		}
 		try {
 			File dir = new File(db.getDirectory(), TICKETS_PATH);
 			return FileUtils.delete(dir);
 		} catch (Exception e) {
 			log.error(null, e);
 		} finally {
 			db.close();
 		}
 		return false;
 	}

 	@Override
 	protected boolean renameImpl(RepositoryModel oldRepository, RepositoryModel newRepository) {
 		return true;
 	}

 	@Override
 	public String toString() {
 		return getClass().getSimpleName();
 	}
 }
	/*
	* Copyright 2014 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.tickets;

	import java.io.File;
	import java.io.IOException;
	import java.text.MessageFormat;
	import java.util.ArrayList;
	import java.util.Collections;
	import java.util.List;
	import java.util.Map;
	import java.util.Set;
	import java.util.TreeSet;
	import java.util.concurrent.ConcurrentHashMap;
	import java.util.concurrent.atomic.AtomicLong;

	import org.eclipse.jgit.lib.Repository;

	import com.gitblit.Constants;
	import com.gitblit.manager.INotificationManager;
	import com.gitblit.manager.IPluginManager;
	import com.gitblit.manager.IRepositoryManager;
	import com.gitblit.manager.IRuntimeManager;
	import com.gitblit.manager.IUserManager;
	import com.gitblit.models.RepositoryModel;
	import com.gitblit.models.TicketModel;
	import com.gitblit.models.TicketModel.Attachment;
	import com.gitblit.models.TicketModel.Change;
	import com.gitblit.utils.ArrayUtils;
	import com.gitblit.utils.FileUtils;
	import com.gitblit.utils.StringUtils;
	import com.google.inject.Inject;
	import com.google.inject.Singleton;

	/**
	* Implementation of a ticket service based on a directory within the repository.
	* All tickets are serialized as a list of JSON changes and persisted in a hashed
	* directory structure, similar to the standard git loose object structure.
	*
	* @author James Moger
	*
	*/
	@Singleton
	public class FileTicketService extends ITicketService {

	private static final String JOURNAL = "journal.json";

	private static final String TICKETS_PATH = "tickets/";

	private final Map<String, AtomicLong> lastAssignedId;

	@Inject
	public FileTicketService(
	IRuntimeManager runtimeManager,
	IPluginManager pluginManager,
	INotificationManager notificationManager,
	IUserManager userManager,
	IRepositoryManager repositoryManager) {

	super(runtimeManager,
	pluginManager,
	notificationManager,
	userManager,
	repositoryManager);

	lastAssignedId = new ConcurrentHashMap<String, AtomicLong>();
	}

	@Override
	public void onStart() {
	log.info("{} started", getClass().getSimpleName());
	}

	@Override
	protected void resetCachesImpl() {
	lastAssignedId.clear();
	}

	@Override
	protected void resetCachesImpl(RepositoryModel repository) {
	if (lastAssignedId.containsKey(repository.name)) {
	lastAssignedId.get(repository.name).set(0);
	}
	}

	@Override
	protected void close() {
	}

	/**
	* Returns the ticket path. This follows the same scheme as Git's object
	* store path where the first two characters of the hash id are the root
	* folder with the remaining characters as a subfolder within that folder.
	*
	* @param ticketId
	* @return the root path of the ticket content in the ticket directory
	*/
	private String toTicketPath(long ticketId) {
	StringBuilder sb = new StringBuilder();
	sb.append(TICKETS_PATH);
	long m = ticketId % 100L;
	if (m < 10) {
	sb.append('0');
	}
	sb.append(m);
	sb.append('/');
	sb.append(ticketId);
	return sb.toString();
	}

	/**
	* Returns the path to the attachment for the specified ticket.
	*
	* @param ticketId
	* @param filename
	* @return the path to the specified attachment
	*/
	private String toAttachmentPath(long ticketId, String filename) {
	return toTicketPath(ticketId) + "/attachments/" + filename;
	}

	/**
	* Ensures that we have a ticket for this ticket id.
	*
	* @param repository
	* @param ticketId
	* @return true if the ticket exists
	*/
	@Override
	public boolean hasTicket(RepositoryModel repository, long ticketId) {
	boolean hasTicket = false;
	Repository db = repositoryManager.getRepository(repository.name);
	try {
	String journalPath = toTicketPath(ticketId) + "/" + JOURNAL;
	hasTicket = new File(db.getDirectory(), journalPath).exists();
	} finally {
	db.close();
	}
	return hasTicket;
	}

	@Override
	public synchronized Set<Long> getIds(RepositoryModel repository) {
	Set<Long> ids = new TreeSet<Long>();
	Repository db = repositoryManager.getRepository(repository.name);
	try {
	// identify current highest ticket id by scanning the paths in the tip tree
	File dir = new File(db.getDirectory(), TICKETS_PATH);
	dir.mkdirs();
	List<File> journals = findAll(dir, JOURNAL);
	for (File journal : journals) {
	// Reconstruct ticketId from the path
	// id/26/326/journal.json
	String path = FileUtils.getRelativePath(dir, journal);
	String tid = path.split("/")[1];
	long ticketId = Long.parseLong(tid);
	ids.add(ticketId);
	}
	} finally {
	if (db != null) {
	db.close();
	}
	}
	return ids;
	}

	/**
	* Assigns a new ticket id.
	*
	* @param repository
	* @return a new long id
	*/
	@Override
	public synchronized long assignNewId(RepositoryModel repository) {
	long newId = 0L;
	Repository db = repositoryManager.getRepository(repository.name);
	try {
	if (!lastAssignedId.containsKey(repository.name)) {
	lastAssignedId.put(repository.name, new AtomicLong(0));
	}
	AtomicLong lastId = lastAssignedId.get(repository.name);
	if (lastId.get() <= 0) {
	Set<Long> ids = getIds(repository);
	for (long id : ids) {
	if (id > lastId.get()) {
	lastId.set(id);
	}
	}
	}

	// assign the id and touch an empty journal to hold it's place
	newId = lastId.incrementAndGet();
	String journalPath = toTicketPath(newId) + "/" + JOURNAL;
	File journal = new File(db.getDirectory(), journalPath);
	journal.getParentFile().mkdirs();
	journal.createNewFile();
	} catch (IOException e) {
	log.error("failed to assign ticket id", e);
	return 0L;
	} finally {
	db.close();
	}
	return newId;
	}

	/**
	* Returns all the tickets in the repository. Querying tickets from the
	* repository requires deserializing all tickets. This is an expensive
	* process and not recommended. Tickets are indexed by Lucene and queries
	* should be executed against that index.
	*
	* @param repository
	* @param filter
	* optional filter to only return matching results
	* @return a list of tickets
	*/
	@Override
	public List<TicketModel> getTickets(RepositoryModel repository, TicketFilter filter) {
	List<TicketModel> list = new ArrayList<TicketModel>();

	Repository db = repositoryManager.getRepository(repository.name);
	try {
	// Collect the set of all json files
	File dir = new File(db.getDirectory(), TICKETS_PATH);
	List<File> journals = findAll(dir, JOURNAL);

	// Deserialize each ticket and optionally filter out unwanted tickets
	for (File journal : journals) {
	String json = null;
	try {
	json = new String(FileUtils.readContent(journal), Constants.ENCODING);
	} catch (Exception e) {
	log.error(null, e);
	}
	if (StringUtils.isEmpty(json)) {
	// journal was touched but no changes were written
	continue;
	}
	try {
	// Reconstruct ticketId from the path
	// id/26/326/journal.json
	String path = FileUtils.getRelativePath(dir, journal);
	String tid = path.split("/")[1];
	long ticketId = Long.parseLong(tid);
	List<Change> changes = TicketSerializer.deserializeJournal(json);
	if (ArrayUtils.isEmpty(changes)) {
	log.warn("Empty journal for {}:{}", repository, journal);
	continue;
	}
	TicketModel ticket = TicketModel.buildTicket(changes);
	ticket.project = repository.projectPath;
	ticket.repository = repository.name;
	ticket.number = ticketId;

	// add the ticket, conditionally, to the list
	if (filter == null) {
	list.add(ticket);
	} else {
	if (filter.accept(ticket)) {
	list.add(ticket);
	}
	}
	} catch (Exception e) {
	log.error("failed to deserialize {}/{}\n{}",
	new Object [] { repository, journal, e.getMessage()});
	log.error(null, e);
	}
	}

	// sort the tickets by creation
	Collections.sort(list);
	return list;
	} finally {
	db.close();
	}
	}

	private List<File> findAll(File dir, String filename) {
	List<File> list = new ArrayList<File>();
	File [] files = dir.listFiles();
	if (files == null) {
	return list;
	}
	for (File file : files) {
	if (file.isDirectory()) {
	list.addAll(findAll(file, filename));
	} else if (file.isFile()) {
	if (file.getName().equalsIgnoreCase(filename)) {
	list.add(file);
	}
	}
	}
	return list;
	}

	/**
	* Retrieves the ticket from the repository.
	*
	* @param repository
	* @param ticketId
	* @return a ticket, if it exists, otherwise null
	*/
	@Override
	protected TicketModel getTicketImpl(RepositoryModel repository, long ticketId) {
	Repository db = repositoryManager.getRepository(repository.name);
	try {
	List<Change> changes = getJournal(db, ticketId);
	if (ArrayUtils.isEmpty(changes)) {
	log.warn("Empty journal for {}:{}", repository, ticketId);
	return null;
	}
	TicketModel ticket = TicketModel.buildTicket(changes);
	if (ticket != null) {
	ticket.project = repository.projectPath;
	ticket.repository = repository.name;
	ticket.number = ticketId;
	}
	return ticket;
	} finally {
	db.close();
	}
	}

	/**
	* Retrieves the journal for the ticket.
	*
	* @param repository
	* @param ticketId
	* @return a journal, if it exists, otherwise null
	*/
	@Override
	protected List<Change> getJournalImpl(RepositoryModel repository, long ticketId) {
	Repository db = repositoryManager.getRepository(repository.name);
	try {
	List<Change> changes = getJournal(db, ticketId);
	if (ArrayUtils.isEmpty(changes)) {
	log.warn("Empty journal for {}:{}", repository, ticketId);
	return null;
	}
	return changes;
	} finally {
	db.close();
	}
	}

	/**
	* Returns the journal for the specified ticket.
	*
	* @param db
	* @param ticketId
	* @return a list of changes
	*/
	private List<Change> getJournal(Repository db, long ticketId) {
	if (ticketId <= 0L) {
	return new ArrayList<Change>();
	}

	String journalPath = toTicketPath(ticketId) + "/" + JOURNAL;
	File journal = new File(db.getDirectory(), journalPath);
	if (!journal.exists()) {
	return new ArrayList<Change>();
	}

	String json = null;
	try {
	json = new String(FileUtils.readContent(journal), Constants.ENCODING);
	} catch (Exception e) {
	log.error(null, e);
	}
	if (StringUtils.isEmpty(json)) {
	return new ArrayList<Change>();
	}
	List<Change> list = TicketSerializer.deserializeJournal(json);
	return list;
	}

	@Override
	public boolean supportsAttachments() {
	return true;
	}

	/**
	* Retrieves the specified attachment from a ticket.
	*
	* @param repository
	* @param ticketId
	* @param filename
	* @return an attachment, if found, null otherwise
	*/
	@Override
	public Attachment getAttachment(RepositoryModel repository, long ticketId, String filename) {
	if (ticketId <= 0L) {
	return null;
	}

	// deserialize the ticket model so that we have the attachment metadata
	TicketModel ticket = getTicket(repository, ticketId);
	Attachment attachment = ticket.getAttachment(filename);

	// attachment not found
	if (attachment == null) {
	return null;
	}

	// retrieve the attachment content
	Repository db = repositoryManager.getRepository(repository.name);
	try {
	String attachmentPath = toAttachmentPath(ticketId, attachment.name);
	File file = new File(db.getDirectory(), attachmentPath);
	if (file.exists()) {
	attachment.content = FileUtils.readContent(file);
	attachment.size = attachment.content.length;
	}
	return attachment;
	} finally {
	db.close();
	}
	}

	/**
	* Deletes a ticket from the repository.
	*
	* @param ticket
	* @return true if successful
	*/
	@Override
	protected synchronized boolean deleteTicketImpl(RepositoryModel repository, TicketModel ticket, String deletedBy) {
	if (ticket == null) {
	throw new RuntimeException("must specify a ticket!");
	}

	boolean success = false;
	Repository db = repositoryManager.getRepository(ticket.repository);
	try {
	String ticketPath = toTicketPath(ticket.number);
	File dir = new File(db.getDirectory(), ticketPath);
	if (dir.exists()) {
	success = FileUtils.delete(dir);
	}
	success = true;
	} finally {
	db.close();
	}
	return success;
	}

	/**
	* Commit a ticket change to the repository.
	*
	* @param repository
	* @param ticketId
	* @param change
	* @return true, if the change was committed
	*/
	@Override
	protected synchronized boolean commitChangeImpl(RepositoryModel repository, long ticketId, Change change) {
	boolean success = false;

	Repository db = repositoryManager.getRepository(repository.name);
	try {
	List<Change> changes = getJournal(db, ticketId);
	changes.add(change);
	String journal = TicketSerializer.serializeJournal(changes).trim();

	String journalPath = toTicketPath(ticketId) + "/" + JOURNAL;
	File file = new File(db.getDirectory(), journalPath);
	file.getParentFile().mkdirs();
	FileUtils.writeContent(file, journal);
	success = true;
	} catch (Throwable t) {
	log.error(MessageFormat.format("Failed to commit ticket {0,number,0} to {1}",
	ticketId, db.getDirectory()), t);
	} finally {
	db.close();
	}
	return success;
	}

	@Override
	protected boolean deleteAllImpl(RepositoryModel repository) {
	Repository db = repositoryManager.getRepository(repository.name);
	if (db == null) {
	// the tickets no longer exist because the db no longer exists
	return true;
	}
	try {
	File dir = new File(db.getDirectory(), TICKETS_PATH);
	return FileUtils.delete(dir);
	} catch (Exception e) {
	log.error(null, e);
	} finally {
	db.close();
	}
	return false;
	}

	@Override
	protected boolean renameImpl(RepositoryModel oldRepository, RepositoryModel newRepository) {
	return true;
	}

	@Override
	public String toString() {
	return getClass().getSimpleName();
	}
	}