/*
|
* 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 FileTicketService start() {
|
log.info("{} started", getClass().getSimpleName());
|
return this;
|
}
|
|
@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();
|
}
|
}
|
