code
stringlengths 1
2.01M
| repo_name
stringlengths 3
62
| path
stringlengths 1
267
| language
stringclasses 231
values | license
stringclasses 13
values | size
int64 1
2.01M
|
|---|---|---|---|---|---|
package org.teremail.schema;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
public class TableBuilder {
private final List<ColumnBuilder> columns = new ArrayList<ColumnBuilder>();
private final List<List<String>> uniques = new ArrayList<List<String>>();
private String name;
public TableBuilder(String name) {
this.name = name;
}
public ColumnBuilder column(String name, DBType type) {
ColumnBuilder cb = new ColumnBuilder(name, type);
columns.add(cb);
return cb;
}
public Table build() {
List<Column> columns = buildColumns();
return new Table(name, columns, uniques);
}
private List<Column> buildColumns() {
Column[] cols = new Column[columns.size()];
int i = 0;
for (ColumnBuilder cb : columns) {
cols[i] = cb.build();
i++;
}
return Arrays.asList(cols);
}
public void addUnique(String...cols) {
uniques.add(Arrays.asList(cols));
}
}
|
zzuoqiang-teremail
|
teremail-core/src/main/java/org/teremail/schema/TableBuilder.java
|
Java
|
lgpl
| 1,046
|
package org.teremail.schema;
public abstract class AbstractDialect implements Dialect {
public String getVarchar(int length) {
return "VARCHAR(" + length + ")";
}
public String getBlob() {
return "BLOB";
}
public String getTimestamp() {
return "TIMESTAMP";
}
public String getTableName(String tableName) {
return tableName;
}
public boolean isDuplicateKey(String state) {
return "23505".equals(state);
}
public String createPagedQuery(String columns, String tables,
String constraints, String orderBy, int pageNo, int pageSize) {
String s = this.getClass().getSimpleName();
throw new UnsupportedOperationException("Dialect: " + s + ", does not support paging");
}
public boolean isPagingSupported() {
return false;
}
}
|
zzuoqiang-teremail
|
teremail-core/src/main/java/org/teremail/schema/AbstractDialect.java
|
Java
|
lgpl
| 877
|
package org.teremail.schema;
/**
* The set of known database types.
*
* @author Michael Barker
*
*/
public class DBTypes {
public static DBType BINARY(final int length) {
return new DBType() {
public String getCreate(Dialect dialect) {
return dialect.generateBinary(length);
}
};
}
public static DBType VARCHAR(final int length) {
return new DBType() {
public String getCreate(Dialect dialect) {
return dialect.getVarchar(length);
}
};
}
public static DBType INT4() {
return new DBType() {
public String getCreate(Dialect dialect) {
return dialect.getInteger(4);
}
};
}
public static DBType INT8() {
return new DBType() {
public String getCreate(Dialect dialect) {
return dialect.getInteger(8);
}
};
}
public static DBType BLOB() {
return new DBType() {
public String getCreate(Dialect dialect) {
return dialect.getBlob();
}
};
}
public static DBType TIMESTAMP() {
return new DBType() {
public String getCreate(Dialect dialect) {
return dialect.getTimestamp();
}
};
}
}
|
zzuoqiang-teremail
|
teremail-core/src/main/java/org/teremail/schema/DBTypes.java
|
Java
|
lgpl
| 1,376
|
package org.teremail.schema;
public class PGDialect extends AbstractDialect {
private static Dialect instance = new PGDialect();
private PGDialect() {}
public String generateBinary(int length) {
return "BYTEA";
}
public String getInteger(int precision) {
switch (precision) {
case 2:
return "INT2";
case 4:
return "INT4";
case 8:
return "INT8";
default:
throw new RuntimeException("Precision: " + precision + " for integer not supported");
}
}
@Override
public String getBlob() {
return "OID";
}
@Override
public String getTableName(String tableName) {
return tableName.toLowerCase();
}
/**
* @see org.teremail.schema.AbstractDialect#createPagedQuery(java.lang.String, java.lang.String, java.lang.String, java.lang.String, int, int)
*/
@Override
public String createPagedQuery(String columns, String tables,
String constraints, String orderBy, int pageNo, int pageSize) {
return "SELECT " + columns +
" FROM " + tables +
" WHERE " + constraints +
" ORDER BY " + orderBy +
" LIMIT " + pageSize + " OFFSET " + (pageNo * pageSize);
}
/**
* @see org.teremail.schema.AbstractDialect#isPagingSupported()
*/
@Override
public boolean isPagingSupported() {
return true;
}
public static Dialect getInstance() {
return instance;
}
}
|
zzuoqiang-teremail
|
teremail-core/src/main/java/org/teremail/schema/PGDialect.java
|
Java
|
lgpl
| 1,572
|
package org.teremail.schema;
public interface DBType {
String getCreate(Dialect dialect);
}
|
zzuoqiang-teremail
|
teremail-core/src/main/java/org/teremail/schema/DBType.java
|
Java
|
lgpl
| 100
|
package org.teremail.schema;
import static java.lang.String.format;
public class H2Dialect extends AbstractDialect {
private final static H2Dialect instance = new H2Dialect();
private H2Dialect() {}
public static Dialect getInstance() {
return instance;
}
public String getInteger(int precision) {
switch (precision) {
case 4:
return "INT";
case 8:
return "BIGINT";
default:
throw new RuntimeException("Integer precision not supported: " + precision);
}
}
public String generateBinary(int length) {
return "BINARY(" + length + ")";
}
@Override
public boolean isDuplicateKey(String state) {
return "23001".equals(state);
}
/**
* @see org.teremail.schema.AbstractDialect#createPagedQuery(java.lang.String, java.lang.String, java.lang.String, java.lang.String, int, int)
*/
@Override
public String createPagedQuery(String columns, String tables,
String constraints, String orderBy, int pageNo, int pageSize) {
return format("SELECT %s FROM %s WHERE %s ORDER BY %s LIMIT %d OFFSET %d",
columns, tables, constraints, orderBy, pageSize, (pageNo * pageSize));
}
@Override
public boolean isPagingSupported() {
return true;
}
}
|
zzuoqiang-teremail
|
teremail-core/src/main/java/org/teremail/schema/H2Dialect.java
|
Java
|
lgpl
| 1,370
|
package org.teremail;
public class MailSystemException extends RuntimeException {
private static final long serialVersionUID = 4245759884099816453L;
public MailSystemException() {
super();
}
public MailSystemException(String message, Throwable cause) {
super(message, cause);
}
public MailSystemException(String message) {
super(message);
}
public MailSystemException(Throwable cause) {
super(cause);
}
}
|
zzuoqiang-teremail
|
teremail-core/src/main/java/org/teremail/MailSystemException.java
|
Java
|
lgpl
| 485
|
package org.teremail;
import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask;
import org.teremail.delivery.Exchange;
import org.teremail.service.ServiceManagerMBean;
import org.teremail.service.ServiceRegistrar;
import com.google.inject.Guice;
import com.google.inject.Injector;
public class ServerSingleton {
private final static FutureTask<ServerSingleton> instance =
new FutureTask<ServerSingleton>(new Callable<ServerSingleton>() {
public ServerSingleton call() throws Exception {
ServerSingleton s = new ServerSingleton();
s.startAll();
return s;
}
});
private final Injector injector;
private ServerSingleton() {
injector = Guice.createInjector(Main.SMTP);
}
private void startAll() {
ServiceManagerMBean serviceManager = injector.getInstance(ServiceRegistrar.class).createServiceManager();
serviceManager.startAll();
serviceManager.bindAll();
}
public static ServerSingleton getInstance() {
instance.run();
try {
return instance.get();
} catch (Exception e) {
e.printStackTrace();
throw new RuntimeException("Server failed to start", e);
}
}
public Exchange getExchange() {
return injector.getInstance(Exchange.class);
}
}
|
zzuoqiang-teremail
|
teremail-core/src/main/java/org/teremail/ServerSingleton.java
|
Java
|
lgpl
| 1,416
|
package org.teremail.message;
public interface EntityVisitor {
void visitSimpleMessage(SimpleMessage simpleMessage);
void visitSimpleEntity(SimpleEntity simpleEntity);
void visitMultipartMessage(MultipartMessage multipartMessage);
void visitMultipartEntity(MultipartEntity multipartEntity);
}
|
zzuoqiang-teremail
|
teremail-core/src/main/java/org/teremail/message/EntityVisitor.java
|
Java
|
lgpl
| 312
|
/**
*
*/
package org.teremail.message;
public enum RFC2822 {
FROM ("From"),
MESSAGE_ID ("Message-ID"),
RECEIVED ("Received"),
RECEIVED_SPF ("Received-SPF"),
RETURN_PATH ("Return-Path"),
DELIVERED_TO ("Delivered-To"),
SENDER ("Sender"),
SUBJECT ("Subject"),
TO ("To"),
DATE ("Date");
private final String name;
RFC2822(String name) {
this.name = name;
}
public String getName() {
return name;
}
}
|
zzuoqiang-teremail
|
teremail-core/src/main/java/org/teremail/message/RFC2822.java
|
Java
|
lgpl
| 494
|
package org.teremail.message;
/**
* Interface for entity that are actual rfc822 messages.
*
* @author Michael Barker
*
*/
public interface Message extends Entity {
public MessageHeaders getHeader();
/**
* True is this message has a content-type of type multipart.
*
* @return
*/
public boolean isMultipart();
}
|
zzuoqiang-teremail
|
teremail-core/src/main/java/org/teremail/message/Message.java
|
Java
|
lgpl
| 354
|
package org.teremail.message;
public class SimpleEntity implements ContentEntity {
private final ContentHeaders header;
private final Content content;
private final String id;
public SimpleEntity(String id, ContentHeaders header, Content content) {
this.id = id;
this.header = header;
this.content = content;
}
public SimpleEntity(ContentHeaders header, Content content) {
this(Entity.UNSAVED_ID, header, content);
}
public String getId() {
return id;
}
public ContentHeaders getContentHeader() {
return header;
}
public Content getContent() {
return content;
}
public void accept(EntityVisitor v) {
v.visitSimpleEntity(this);
}
public EntityType getType() {
return EntityType.SIMPLE_ENTITY;
}
}
|
zzuoqiang-teremail
|
teremail-core/src/main/java/org/teremail/message/SimpleEntity.java
|
Java
|
lgpl
| 859
|
package org.teremail.message;
import static java.lang.String.format;
import static java.util.regex.Pattern.compile;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class AddressParser {
private final static Pattern SMTP_ADDRESS = compile("<(?:[^:]*:)?([^@]*)@([^@]*)>");
private final static Pattern POSTMASTER_ADDRESS = compile("<Postmaster(?:@([^>]*))?>");
/**
* Parses and SMTP address in the form of a forward path. I.e. stringly
* <user@domain>
* @param addressStr
* @return
* @throws AddressFormatException
*/
public static Address parseSMTP(String addressStr) throws AddressFormatException {
if (addressStr == null) {
throw new AddressFormatException("Address is null");
}
Matcher m = SMTP_ADDRESS.matcher(addressStr);
if (m.matches() && m.groupCount() == 2) {
String user = m.group(1);
String domain = m.group(2);
return new Address(user, domain);
} else {
String msg = format("The address '%s' is not valid", addressStr);
throw new AddressFormatException(msg);
}
}
/**
* Parses an address string, but will first check to see if is a Postmaster
* address.
*
* @param The address as a string
* @return
* @throws AddressFormatException
*/
public static Address parseSMTPPostmaster(String addressStr) throws AddressFormatException {
if (addressStr == null) {
throw new AddressFormatException("Address is null");
}
Matcher m = POSTMASTER_ADDRESS.matcher(addressStr);
if (m.matches()) {
if (m.groupCount() == 1) {
return new Address("Postmaster", m.group(1));
} else {
return new Address("Postmaster");
}
} else {
return parseSMTP(addressStr);
}
}
}
|
zzuoqiang-teremail
|
teremail-core/src/main/java/org/teremail/message/AddressParser.java
|
Java
|
lgpl
| 1,981
|
package org.teremail.message;
public class EntityVisitorAdaptor implements EntityVisitor {
public void visitMultipartEntity(MultipartEntity multipartEntity) {
for (Entity e : multipartEntity) {
e.accept(this);
}
}
public void visitMultipartMessage(MultipartMessage multipartMessage) {
for (Entity e : multipartMessage) {
e.accept(this);
}
}
public void visitSimpleEntity(SimpleEntity simpleEntity) {
}
public void visitSimpleMessage(SimpleMessage simpleMessage) {
}
}
|
zzuoqiang-teremail
|
teremail-core/src/main/java/org/teremail/message/EntityVisitorAdaptor.java
|
Java
|
lgpl
| 564
|
package org.teremail.message;
public interface ContentEntity extends Entity {
Content getContent();
}
|
zzuoqiang-teremail
|
teremail-core/src/main/java/org/teremail/message/ContentEntity.java
|
Java
|
lgpl
| 109
|
package org.teremail.message;
/**
* The headers that house the meta data for individual pieces of content.
*
* @author Michael Barker
*
*/
public interface ContentHeaders {
String getContentType();
String getBoundary();
}
|
zzuoqiang-teremail
|
teremail-core/src/main/java/org/teremail/message/ContentHeaders.java
|
Java
|
lgpl
| 244
|
package org.teremail.message;
public final class Address {
private final String user;
private final String domain;
public Address(String user, String domain) {
this.user = user;
this.domain = domain;
}
public Address(String user) {
this(user, "");
}
public String getUser() {
return user;
}
public String getDomain() {
return domain;
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + ((domain == null) ? 0 : domain.hashCode());
result = prime * result + ((user == null) ? 0 : user.hashCode());
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
final Address other = (Address) obj;
if (domain == null) {
if (other.domain != null)
return false;
} else if (!domain.equals(other.domain))
return false;
if (user == null) {
if (other.user != null)
return false;
} else if (!user.equals(other.user))
return false;
return true;
}
}
|
zzuoqiang-teremail
|
teremail-core/src/main/java/org/teremail/message/Address.java
|
Java
|
lgpl
| 1,350
|
package org.teremail.message;
public class Content {
private final String id;
public Content(String id) {
this.id = id;
}
public Content(long id) {
this.id = String.valueOf(id);
}
public String getId() {
return id;
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + ((id == null) ? 0 : id.hashCode());
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
final Content other = (Content) obj;
if (id == null) {
if (other.id != null)
return false;
} else if (!id.equals(other.id))
return false;
return true;
}
}
|
zzuoqiang-teremail
|
teremail-core/src/main/java/org/teremail/message/Content.java
|
Java
|
lgpl
| 930
|
package org.teremail.message.builder;
import org.teremail.message.Entity;
public interface EntityBuilder {
Entity build();
boolean hasChanged();
String getId();
boolean isMultipart();
}
|
zzuoqiang-teremail
|
teremail-core/src/main/java/org/teremail/message/builder/EntityBuilder.java
|
Java
|
lgpl
| 209
|
package org.teremail.message.builder;
import org.teremail.message.Content;
import org.teremail.message.ContentHeaders;
import org.teremail.message.SimpleEntity;
public class SimpleEntityBuilder implements ContentEntityBuilder {
private Content content;
private final SimpleEntity original;
private boolean hasChanged = false;
private String id;
private final ContentHeadersBuilder contentHeadersBuilder;
public SimpleEntityBuilder(SimpleEntity original,
ContentHeadersBuilder contentHeadersBuilder) {
this.original = original;
this.contentHeadersBuilder = contentHeadersBuilder;
}
public SimpleEntityBuilder(ContentHeadersBuilder contentHeadersBuilder) {
this(null, contentHeadersBuilder);
}
public SimpleEntityBuilder() {
this(null, new ContentHeadersBuilder());
}
public SimpleEntityBuilder(String type, String subType) {
this();
contentHeadersBuilder.setContentType(type, subType);
}
public SimpleEntityBuilder(SimpleEntity simpleEntity) {
this(simpleEntity, new ContentHeadersBuilder(simpleEntity.getContentHeader()));
}
public void setId(String id) {
hasChanged = true;
this.id = id;
}
public SimpleEntityBuilder setContent(Content content) {
this.content = content;
hasChanged = true;
return this;
}
public boolean hasChanged() {
return hasChanged || original == null;
}
public SimpleEntity build() {
if (hasChanged()) {
ContentHeaders header = contentHeadersBuilder.build();
return new SimpleEntity(id, header, content);
} else {
return original;
}
}
public void setContentHeaders(String contentHeaders) {
contentHeadersBuilder.load(contentHeaders);
}
public String getId() {
return id;
}
public boolean isMultipart() {
return false;
}
}
|
zzuoqiang-teremail
|
teremail-core/src/main/java/org/teremail/message/builder/SimpleEntityBuilder.java
|
Java
|
lgpl
| 2,006
|
package org.teremail.message.builder;
import org.teremail.message.Message;
public interface MessageBuilder extends EntityBuilder {
Message build();
}
|
zzuoqiang-teremail
|
teremail-core/src/main/java/org/teremail/message/builder/MessageBuilder.java
|
Java
|
lgpl
| 157
|
package org.teremail.message.builder;
import org.teremail.message.Entity;
import org.teremail.message.MultipartEntity;
import org.teremail.message.MultipartMessage;
import org.teremail.message.SimpleEntity;
import org.teremail.message.SimpleMessage;
public class Builders {
public static EntityBuilder createBuilder(Entity entity) {
BuilderEntityVisitor bev = new BuilderEntityVisitor();
entity.accept(bev);
return bev.getEntityBuilder();
}
public static MultipartMessageBuilder create(MultipartMessage message) {
return (MultipartMessageBuilder) createBuilder(message);
}
public static MultipartEntityBuilder create(MultipartEntity multipartEntity) {
return (MultipartEntityBuilder) createBuilder(multipartEntity);
}
public static SimpleMessageBuilder create(SimpleMessage message) {
return (SimpleMessageBuilder) createBuilder(message);
}
public static SimpleEntityBuilder create(SimpleEntity simpleEntity) {
return (SimpleEntityBuilder) createBuilder(simpleEntity);
}
}
|
zzuoqiang-teremail
|
teremail-core/src/main/java/org/teremail/message/builder/Builders.java
|
Java
|
lgpl
| 1,088
|
package org.teremail.message.builder;
public class MalformedHeaderException extends RuntimeException {
private static final long serialVersionUID = 1L;
public MalformedHeaderException() {
super();
}
public MalformedHeaderException(String message, Throwable cause) {
super(message, cause);
}
public MalformedHeaderException(String message) {
super(message);
}
public MalformedHeaderException(Throwable cause) {
super(cause);
}
}
|
zzuoqiang-teremail
|
teremail-core/src/main/java/org/teremail/message/builder/MalformedHeaderException.java
|
Java
|
lgpl
| 507
|
/**
*
*/
package org.teremail.message.builder;
import java.util.List;
import org.teremail.message.Entity;
import org.teremail.message.EntityVisitor;
import org.teremail.message.Multipart;
import org.teremail.message.MultipartEntity;
import org.teremail.message.MultipartMessage;
import org.teremail.message.SimpleEntity;
import org.teremail.message.SimpleMessage;
import com.google.common.collect.Lists;
class BuilderEntityVisitor implements EntityVisitor {
private EntityBuilder builder = null;
private List<EntityBuilder> getEntityBuilders(Multipart multipart) {
List<EntityBuilder> partBuilders = Lists.newArrayList();
for (Entity e : multipart) {
BuilderEntityVisitor bev = new BuilderEntityVisitor();
e.accept(bev);
partBuilders.add(bev.getEntityBuilder());
}
return partBuilders;
}
public void visitMultipartEntity(MultipartEntity multipartEntity) {
List<EntityBuilder> partBuilders = getEntityBuilders(multipartEntity);
builder = new MultipartEntityBuilder(multipartEntity, partBuilders);
}
public void visitMultipartMessage(MultipartMessage multipartMessage) {
List<EntityBuilder> partBuilders = getEntityBuilders(multipartMessage);
builder = new MultipartMessageBuilder(multipartMessage, partBuilders);
}
public void visitSimpleEntity(SimpleEntity simpleEntity) {
builder = new SimpleEntityBuilder(simpleEntity);
}
public void visitSimpleMessage(SimpleMessage simpleMessage) {
builder = new SimpleMessageBuilder(simpleMessage);
}
public EntityBuilder getEntityBuilder() {
return builder;
}
}
|
zzuoqiang-teremail
|
teremail-core/src/main/java/org/teremail/message/builder/BuilderEntityVisitor.java
|
Java
|
lgpl
| 1,707
|
package org.teremail.message.builder;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import org.teremail.message.ContentHeaders;
import org.teremail.message.ContentHeadersImpl;
import org.teremail.panto.ContentDisposition;
import org.teremail.panto.ContentHeader;
import org.teremail.panto.ContentTransferEncoding;
import org.teremail.panto.ContentType;
import org.teremail.panto.ParseException;
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.Maps;
public class ContentHeadersBuilder {
private final Map<String,ContentHeader> headers = Maps.newLinkedHashMap();
private boolean hasChanged = false;
public ContentHeadersBuilder(ContentHeaders header) {
// TODO: Think about performance here.
load(header.toString());
}
public ContentHeadersBuilder() {
hasChanged = true;
}
public ContentHeadersBuilder set(ContentHeader ch) {
headers.put(ch.getName(), ch);
hasChanged = true;
return this;
}
public ContentHeadersBuilder setContentType(String type, String subType) {
return set(new ContentType(type, subType));
}
public ContentHeadersBuilder setContentType(String type, String subType,
Map<String, String> params) {
return set(new ContentType(null, type, subType, params));
}
public ContentHeadersBuilder setContentDisposition(String type, Map<String, String> cdp) {
return set(new ContentDisposition(type, cdp));
}
public ContentHeadersBuilder setContentTransferEncoding(String type) {
Map<String,String> params = ImmutableMap.of();
return set(new ContentTransferEncoding(null, type, null, params));
}
public ContentHeaders build() {
return new ContentHeadersImpl(Collections.unmodifiableMap(headers));
}
/**
* Loads all of the headers from a string. If the string is null we do
* nothing. This will clear out all of the existing headers first.
*
* @param headerStr
*/
public void load(String headerStr) {
headers.clear();
if (headerStr != null) {
String[] lines = headerStr.split("\r\n");
StringBuilder sb = null;
for (String s : lines) {
if (s.trim().length() != 0) {
if (s.startsWith(" ") || s.startsWith("\t")) {
if (sb != null) {
// Maintain the newline.
sb.append("\r\n");
sb.append(s);
} else {
throw new MalformedHeaderException("Malformed Header: " + s);
}
} else {
if (sb == null) {
sb = new StringBuilder();
} else {
addHeader(sb.toString());
sb = new StringBuilder();
}
sb.append(s);
}
}
}
if (sb != null) {
addHeader(sb.toString());
}
}
}
private void addHeader(String line) {
ContentHeader ch = parseHeader(line);
headers.put(ch.getName(), ch);
}
private ContentHeader parseHeader(String line) {
ContentHeader ch = null;
try {
ch = ContentType.parse(line);
if (ch == null) {
ch = ContentDisposition.parse(line);
if (ch == null) {
ch = ContentTransferEncoding.parse(line);
if (ch == null ){
ch = GenericContentHeader.parse(line);
if (ch == null) {
throw new MalformedHeaderException(line);
}
}
}
}
} catch (ParseException e) {
throw new MalformedHeaderException(line);
}
return ch;
}
private static class GenericContentHeader extends ContentHeader {
private final String name;
private final static Pattern PATTERN =
Pattern.compile("([^:]*):(.*)", Pattern.DOTALL | Pattern.CASE_INSENSITIVE);
protected GenericContentHeader(String text, String name, String value) {
super(text, value.trim(), null, new HashMap<String, String>());
this.name = name;
}
public static GenericContentHeader parse(String line) throws ParseException {
Matcher m = PATTERN.matcher(line);
if (m.matches() && m.groupCount() == 2) {
return new GenericContentHeader(line, m.group(1), m.group(2));
} else {
return null;
}
}
@Override
public String getName() {
return name;
}
@Override
public String getDefaultParameter(String key) {
return null;
}
}
public boolean hasChanged() {
return hasChanged;
}
public void add(String fieldData) {
addHeader(fieldData);
}
}
|
zzuoqiang-teremail
|
teremail-core/src/main/java/org/teremail/message/builder/ContentHeadersBuilder.java
|
Java
|
lgpl
| 5,392
|
package org.teremail.message.builder;
import java.util.ArrayList;
import java.util.List;
import org.teremail.message.Content;
import org.teremail.message.ContentHeaders;
import org.teremail.message.Entity;
import org.teremail.message.MultipartEntity;
/**
* Utility class to help construct a multipart entity, i.e. a list of child
* parts.
*
* @author Michael Barker
*
*/
public class MultipartEntityBuilder implements MultipartBuilder {
private final MultipartEntity originalEntity;
private final List<EntityBuilder> partBuilders;
private final ContentHeadersBuilder contentHeadersBuilder;
private boolean hasChanged = false;
private String preamble;
private String epilogue;
private String id;
public MultipartEntityBuilder(MultipartEntity originalEntity,
ContentHeadersBuilder contentHeadersBuilder,
List<EntityBuilder> partBuilders) {
this.originalEntity = originalEntity;
this.contentHeadersBuilder = contentHeadersBuilder;
this.partBuilders = partBuilders;
}
public MultipartEntityBuilder(ContentHeadersBuilder contentHeadersBuilder,
List<EntityBuilder> partBuilders) {
this(null, contentHeadersBuilder, partBuilders);
}
public MultipartEntityBuilder(ContentHeadersBuilder contentHeadersBuilder) {
this(contentHeadersBuilder, new ArrayList<EntityBuilder>());
}
public MultipartEntityBuilder(MultipartEntity multipartEntity,
List<EntityBuilder> partBuilders) {
this(multipartEntity,
new ContentHeadersBuilder(multipartEntity.getContentHeader()),
partBuilders);
}
public MultipartEntityBuilder() {
this(null, new ContentHeadersBuilder(), new ArrayList<EntityBuilder>());
}
public SimpleEntityBuilder addSimpleEntity(Content c) {
hasChanged = true;
SimpleEntityBuilder seb = new SimpleEntityBuilder();
seb.setContent(c);
partBuilders.add(seb);
return seb;
}
public MultipartEntityBuilder setPreamble(String preamble) {
this.preamble = preamble;
return this;
}
public MultipartEntityBuilder setEpilogue(String epilogue) {
this.epilogue = epilogue;
return this;
}
public boolean hasChanged() {
return hasChanged || originalEntity == null || childPartChanged();
}
private boolean childPartChanged() {
for (EntityBuilder eb : partBuilders) {
if (eb.hasChanged()) {
return true;
}
}
return false;
}
public MultipartEntity build() {
if (hasChanged()) {
List<Entity> parts = new ArrayList<Entity>();
for (EntityBuilder eb : partBuilders) {
parts.add(eb.build());
}
ContentHeaders ch = contentHeadersBuilder.build();
return new MultipartEntity(id, ch, preamble, parts, epilogue);
} else {
return originalEntity;
}
}
public MultipartEntityBuilder setId(String id) {
this.id = id;
hasChanged = true;
return this;
}
public String getId() {
return id;
}
public MultipartEntityBuilder clearParts() {
partBuilders.clear();
hasChanged = true;
return this;
}
public MultipartEntityBuilder addEntityBuilder(EntityBuilder entityBuilder) {
partBuilders.add(entityBuilder);
hasChanged = true;
return this;
}
public boolean isMultipart() {
return true;
}
public void setContentHeaders(String contentHeaders) {
contentHeadersBuilder.load(contentHeaders);
}
}
|
zzuoqiang-teremail
|
teremail-core/src/main/java/org/teremail/message/builder/MultipartEntityBuilder.java
|
Java
|
lgpl
| 3,758
|
package org.teremail.message.builder;
import java.util.ArrayList;
import java.util.List;
import org.teremail.message.ContentHeaders;
import org.teremail.message.Entity;
import org.teremail.message.MessageHeaders;
import org.teremail.message.MultipartMessage;
import com.google.common.collect.Lists;
public class MultipartMessageBuilder implements MultipartBuilder, MessageBuilder {
private final List<EntityBuilder> partBuilders;
private MultipartMessage orginalMessage;
private final MessageHeadersBuilder headersBuilder;
private String preamble;
private String epilogue;
private boolean hasChanged = true;
private String id;
private ContentHeadersBuilder contentHeadersBuilder;
public MultipartMessageBuilder(MessageHeadersBuilder headersBuilder,
List<EntityBuilder> partBuilders,
ContentHeadersBuilder contentHeadersBuilder) {
this.headersBuilder = headersBuilder;
this.partBuilders = partBuilders;
this.contentHeadersBuilder = contentHeadersBuilder;
}
public MultipartMessageBuilder(MessageHeadersBuilder headersBuilder,
ContentHeadersBuilder contentHeadersBuilder) {
this(headersBuilder, new ArrayList<EntityBuilder>(),
contentHeadersBuilder);
}
public MultipartMessageBuilder() {
this(new MessageHeadersBuilder(), new ArrayList<EntityBuilder>(),
new ContentHeadersBuilder());
}
public MultipartMessageBuilder(MultipartMessage message,
List<EntityBuilder> partBuilders) {
this(new MessageHeadersBuilder(message.getHeader()), partBuilders,
new ContentHeadersBuilder(message.getContentHeader()));
this.orginalMessage = message;
this.epilogue = orginalMessage.getEpilogue();
this.preamble = orginalMessage.getPreamble();
hasChanged = false;
}
public MultipartMessageBuilder setId(String id) {
this.id = id;
hasChanged = true;
return this;
}
public String getId() {
return id;
}
public MultipartMessageBuilder setPreamble(String preamble) {
hasChanged = true;
this.preamble = preamble;
return this;
}
public MultipartMessageBuilder setEpilogue(String epilogue) {
this.epilogue = epilogue;
return this;
}
public SimpleEntityBuilder addSimpleEntity() {
SimpleEntityBuilder b = new SimpleEntityBuilder();
partBuilders.add(b);
return b;
}
public SimpleEntityBuilder addSimpleEntity(String type, String subType) {
SimpleEntityBuilder b = new SimpleEntityBuilder(type, subType);
partBuilders.add(b);
return b;
}
public MultipartMessage build() {
if (hasChanged()) {
MessageHeaders header = headersBuilder.build();
ContentHeaders contentHeader = contentHeadersBuilder.build();
List<Entity> parts = Lists.newArrayList();
for (EntityBuilder eb : partBuilders) {
parts.add(eb.build());
}
return new MultipartMessage(id, contentHeader, header, preamble,
parts, epilogue);
} else {
return orginalMessage;
}
}
public boolean hasChanged() {
return hasChanged || orginalMessage == null
|| headersBuilder.hasChanged()
|| contentHeadersBuilder.hasChanged()
|| childPartChanged();
}
private boolean childPartChanged() {
for (EntityBuilder eb : partBuilders) {
if (eb.hasChanged()) {
return true;
}
}
return false;
}
public MessageHeadersBuilder getHeaderBuilder() {
return headersBuilder;
}
public MultipartMessageBuilder clearParts() {
partBuilders.clear();
hasChanged = true;
return this;
}
public MultipartMessageBuilder addEntityBuilder(EntityBuilder entityBuilder) {
partBuilders.add(entityBuilder);
hasChanged = true;
return this;
}
public void setHeaders(String messageHeaders) {
headersBuilder.load(messageHeaders);
}
public boolean isMultipart() {
return true;
}
public void setContentHeaders(String contentHeaders) {
contentHeadersBuilder.load(contentHeaders);
}
}
|
zzuoqiang-teremail
|
teremail-core/src/main/java/org/teremail/message/builder/MultipartMessageBuilder.java
|
Java
|
lgpl
| 4,460
|
package org.teremail.message.builder;
import org.teremail.message.Content;
import org.teremail.message.ContentHeaders;
import org.teremail.message.Entity;
import org.teremail.message.MessageHeaders;
import org.teremail.message.SimpleMessage;
public class SimpleMessageBuilder implements ContentEntityBuilder, MessageBuilder {
private Content content;
private ContentHeaders contentHeader;
private final MessageHeadersBuilder headersBuilder;
private String id = Entity.UNSAVED_ID;
private SimpleMessage original;
private boolean hasChanged = true;
public SimpleMessageBuilder(ContentHeaders contentHeader,
MessageHeadersBuilder headersBuilder, Content content) {
this.contentHeader = contentHeader;
this.headersBuilder = headersBuilder;
this.content = content;
}
public SimpleMessageBuilder(SimpleMessage simpleMessage) {
this(simpleMessage.getContentHeader(),
new MessageHeadersBuilder(simpleMessage.getHeader()),
simpleMessage.getContent());
this.original = simpleMessage;
hasChanged = false;
}
public SimpleMessageBuilder() {
this(null, new MessageHeadersBuilder(), null);
}
public SimpleMessageBuilder setContent(Content content) {
hasChanged = true;
this.content = content;
return this;
}
public SimpleMessageBuilder setId(String id) {
hasChanged = true;
this.id = id;
return this;
}
public String getId() {
return id;
}
public MessageHeadersBuilder getHeaderBuilder() {
return headersBuilder;
}
public boolean hasChanged() {
return hasChanged || original == null || headersBuilder.hasChanged();
}
public SimpleMessage build() {
if (hasChanged()) {
MessageHeaders header = headersBuilder.build();
SimpleMessage message = new SimpleMessage(id, contentHeader, header, content);
return message;
} else {
return original;
}
}
public void setHeaders(String messageHeaders) {
headersBuilder.load(messageHeaders);
}
public boolean isMultipart() {
return false;
}
}
|
zzuoqiang-teremail
|
teremail-core/src/main/java/org/teremail/message/builder/SimpleMessageBuilder.java
|
Java
|
lgpl
| 2,272
|
package org.teremail.message.builder;
public interface MultipartBuilder extends EntityBuilder {
MultipartBuilder addEntityBuilder(EntityBuilder eb);
MultipartBuilder setPreamble(String preamble);
MultipartBuilder setEpilogue(String epilogue);
}
|
zzuoqiang-teremail
|
teremail-core/src/main/java/org/teremail/message/builder/MultipartBuilder.java
|
Java
|
lgpl
| 258
|
package org.teremail.message.builder;
import java.io.IOException;
import java.io.InputStream;
import java.util.Arrays;
import java.util.Collection;
import java.util.List;
import java.util.Set;
import org.teremail.message.Header;
import org.teremail.message.MessageHeaders;
import org.teremail.message.MessageHeadersImpl;
import org.teremail.message.RFC2822;
import org.teremail.panto.IOUtil;
import com.google.common.collect.ImmutableSet;
import com.google.common.collect.LinkedListMultimap;
import com.google.common.collect.ListMultimap;
import com.google.common.collect.Multimap;
public class MessageHeadersBuilder {
private final Set<String> TRACE_KEYS = ImmutableSet.of(
RFC2822.RECEIVED.getName().toLowerCase(),
RFC2822.RECEIVED_SPF.getName().toLowerCase(),
RFC2822.DELIVERED_TO.getName().toLowerCase());
private final ListMultimap<String,Header> returnPath =
LinkedListMultimap.create();
private final ListMultimap<String,Header> receivedHeaders =
LinkedListMultimap.create();
private final ListMultimap<String,Header> headers =
LinkedListMultimap.create();
private boolean hasChanged;
public MessageHeadersBuilder() {
hasChanged = true;
}
public MessageHeadersBuilder(MessageHeaders original) {
for (Header h : original) {
putHeader(h.getName(), h);
}
hasChanged = false;
}
private Multimap<String,Header> getHeadersMap(String key) {
if (RFC2822.RETURN_PATH.getName().equalsIgnoreCase(key)) {
return returnPath;
} else if (TRACE_KEYS.contains(key)) {
return receivedHeaders;
} else {
return headers;
}
}
private void putHeader(String key, Header header) {
String lcKey = key.toLowerCase();
if (RFC2822.RETURN_PATH.getName().equalsIgnoreCase(key)) {
returnPath.put(lcKey, header);
} else if (TRACE_KEYS.contains(lcKey)) {
receivedHeaders.put(RFC2822.RECEIVED.getName().toLowerCase(), header);
} else {
headers.put(lcKey, header);
}
}
private void replaceHeader(String key, List<Header> headers) {
String lcKey = key.toLowerCase();
getHeadersMap(lcKey).replaceValues(lcKey, headers);
}
private Collection<Header> getHeaders(String key) {
String lcKey = key.toLowerCase();
return getHeadersMap(lcKey).get(lcKey);
}
private Header getHeader(String key) {
String lcKey = key.toLowerCase();
Collection<Header> headers = getHeadersMap(lcKey).get(lcKey);
if (headers.size() > 0) {
return headers.iterator().next();
} else {
return null;
}
}
public MessageHeadersBuilder addReceived(String received) {
return add(RFC2822.RECEIVED, received);
}
public MessageHeadersBuilder setMessageId(String messageId) {
return set(RFC2822.MESSAGE_ID, messageId);
}
public MessageHeadersBuilder setReturnPath(String returnPath) {
return set(RFC2822.RETURN_PATH, returnPath);
}
public MessageHeadersBuilder setTo(String to) {
return set(RFC2822.TO, to);
}
public MessageHeadersBuilder setSubject(String subject) {
return set(RFC2822.SUBJECT, subject);
}
public MessageHeadersBuilder setFrom(String from) {
return set(RFC2822.FROM, from);
}
public MessageHeadersBuilder setSender(String sender) {
return set(RFC2822.SENDER, sender);
}
public MessageHeadersBuilder setDate(String date) {
return set(RFC2822.DATE, date);
}
private MessageHeadersBuilder add(RFC2822 name, String value) {
return add(name.getName(), value);
}
private MessageHeadersBuilder add(String name, String value) {
hasChanged = true;
Header header = new Header(name, value);
putHeader(name, header);
return this;
}
private MessageHeadersBuilder set(RFC2822 name, String value) {
return set(name.getName(), value);
}
public MessageHeadersBuilder set(String name, String value) {
hasChanged = true;
Header header = new Header(name, value);
replaceHeader(name, Arrays.asList(header));
return this;
}
private Collection<Header> getHeaders(RFC2822 key) {
return getHeaders(key.getName());
}
private Header getHeader(RFC2822 key) {
return getHeader(key.getName());
}
public MessageHeaders build() {
return new MessageHeadersImpl(getHeader(RFC2822.RETURN_PATH),
getHeaders(RFC2822.RECEIVED), headers);
}
public boolean hasChanged() {
return hasChanged;
}
public void load(String messageHeaders) {
String[] lines = messageHeaders.split("\r\n");
StringBuilder sb = null;
for (String s : lines) {
if (s.trim().length() != 0) {
if (s.startsWith(" ") || s.startsWith("\t")) {
if (sb != null) {
// Maintain the newline.
sb.append("\r\n");
sb.append(s);
} else {
throw new MalformedHeaderException("Malformed Header: " + s);
}
} else {
if (sb == null) {
sb = new StringBuilder();
} else {
addHeader(sb);
sb = new StringBuilder();
}
sb.append(s);
}
}
}
if (sb != null) {
addHeader(sb);
}
}
public MessageHeadersBuilder add(String s) {
addHeader(new StringBuilder(s));
return this;
}
private void addHeader(StringBuilder sb) {
int idx = sb.indexOf(":");
if (idx > -1) {
String name = sb.substring(0, idx);
String value = sb.substring(idx + 1).trim();
add(name, value);
} else {
throw new MalformedHeaderException("Malformed Header: " + sb);
}
}
public int load(InputStream in) throws IOException {
return load(in, "US-ASCII");
}
/**
* Loads the message headers from an input stream. Converting using the
* specified charset. It will skip any empty lines first, then will stop
* when it receives an empty line that occurs after some text.
*
* @param in
* @param charset
* @return
* @throws IOException
*/
public int load(InputStream in, String charset) throws IOException {
int numRead = 0;
StringBuilder line = new StringBuilder();
StringBuilder header = null;
// Skip any empty lines.
// Return if we only received empty lines followed by EOF.
while (line.length() == 0) {
int bytesRead = IOUtil.appendLine(line, in, charset);
if (bytesRead == 0) {
return numRead;
}
numRead += bytesRead;
}
do {
String s = line.toString();
if (s.startsWith(" ") || s.startsWith("\t")) {
if (header == null) {
throw new MalformedHeaderException("Malformed Header: " + s);
}
// Maintain the newline.
header.append("\r\n");
header.append(s);
} else {
if (header != null) {
addHeader(header);
}
header = new StringBuilder();
header.append(s);
}
line.delete(0, line.length());
numRead += IOUtil.appendLine(line, in, charset);
} while (line.length() > 0);
addHeader(header);
return numRead;
}
public static MessageHeadersBuilder create() {
return new MessageHeadersBuilder();
}
}
|
zzuoqiang-teremail
|
teremail-core/src/main/java/org/teremail/message/builder/MessageHeadersBuilder.java
|
Java
|
lgpl
| 8,218
|
package org.teremail.message.builder;
import org.teremail.message.Content;
public interface ContentEntityBuilder extends EntityBuilder {
ContentEntityBuilder setContent(Content content);
}
|
zzuoqiang-teremail
|
teremail-core/src/main/java/org/teremail/message/builder/ContentEntityBuilder.java
|
Java
|
lgpl
| 196
|
package org.teremail.message;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.nio.charset.Charset;
import java.util.ArrayDeque;
import java.util.Deque;
import org.teremail.message.builder.ContentEntityBuilder;
import org.teremail.message.builder.ContentHeadersBuilder;
import org.teremail.message.builder.EntityBuilder;
import org.teremail.message.builder.MessageHeadersBuilder;
import org.teremail.message.builder.MultipartBuilder;
import org.teremail.message.builder.MultipartEntityBuilder;
import org.teremail.message.builder.MultipartMessageBuilder;
import org.teremail.message.builder.SimpleEntityBuilder;
import org.teremail.message.builder.SimpleMessageBuilder;
import org.teremail.panto.BodyHeader;
import org.teremail.panto.ContentHandler;
import org.teremail.store.Store;
import org.teremail.util.IO;
public class FooContentHandler implements ContentHandler {
private final Deque<EntityBuilder> builderStack =
new ArrayDeque<EntityBuilder>();
private EntityBuilder lastBuilder;
private final Store store;
private boolean isMessage = false;
private MessageHeadersBuilder headers = null;
private ContentHeadersBuilder contentHeaders = new ContentHeadersBuilder();
public FooContentHandler(Store store) {
this.store = store;
}
public void body(BodyHeader header, InputStream is) throws IOException {
if (isMessage) {
assert headers != null;
SimpleMessageBuilder smb = new SimpleMessageBuilder(contentHeaders.build(), headers, null);
builderStack.push(smb);
isMessage = false;
headers = null;
} else {
assert contentHeaders != null;
builderStack.push(new SimpleEntityBuilder(contentHeaders));
}
ContentEntityBuilder b = (ContentEntityBuilder) builderStack.peek();
String id = store.createStoreItem();
OutputStream out = store.getOutputStream(id);
IO.copy(is, out);
out.flush();
out.close();
b.setContent(new Content(id));
popAndAddToLast();
}
private void popAndAddToLast() {
lastBuilder = builderStack.pop();
if (builderStack.size() > 0) {
MultipartBuilder mb = (MultipartBuilder) builderStack.peek();
mb.addEntityBuilder(lastBuilder);
}
}
public void endBodyPart() {
}
public void endHeader() {
}
public void endMessage() {
}
public void endMultipart() {
popAndAddToLast();
}
public void epilogue(InputStream in) throws IOException {
MultipartBuilder mb = (MultipartBuilder) builderStack.peek();
String epilogue = IO.toString(in, Charset.forName("US-ASCII"));
mb.setEpilogue(epilogue);
}
public void field(String fieldData) {
if (isMessage) {
headers.add(fieldData);
} else {
contentHeaders.add(fieldData);
}
}
public void preamble(InputStream in) throws IOException {
MultipartBuilder mb = (MultipartBuilder) builderStack.peek();
String preamble = IO.toString(in, Charset.forName("US-ASCII"));
mb.setPreamble(preamble);
}
public void startBodyPart() {
}
public void startHeader() {
if (isMessage) {
headers = new MessageHeadersBuilder();
} else {
contentHeaders = new ContentHeadersBuilder();
}
}
public void startMessage() {
isMessage = true;
}
public void startMultipart(BodyHeader header) {
if (isMessage) {
builderStack.push(new MultipartMessageBuilder(headers, contentHeaders));
isMessage = false;
} else {
builderStack.push(new MultipartEntityBuilder(contentHeaders));
}
}
public Message getMessage() {
return (Message) lastBuilder.build();
}
}
|
zzuoqiang-teremail
|
teremail-core/src/main/java/org/teremail/message/FooContentHandler.java
|
Java
|
lgpl
| 4,008
|
package org.teremail.message;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Map;
import org.teremail.panto.ContentDisposition;
import org.teremail.panto.ContentHeader;
import org.teremail.panto.ContentTransferEncoding;
import org.teremail.panto.ContentType;
import org.teremail.store.Strings;
import com.google.common.collect.ImmutableMap;
public class ContentHeadersImpl implements ContentHeaders {
private final static Map<String,ContentHeader> EMPTY_HEADERS = ImmutableMap.of();
private final static Map<String,ContentHeader> DEFAULT_HEADERS = ImmutableMap.of(
RFC2045.CONTENT_TYPE.getName(), ContentType.DEFAULT,
RFC2045.CONTENT_DISPOSITION.getName(), ContentDisposition.DEFAULT,
RFC2045.CONTENT_TRANSFER_ENCODING.getName(), ContentTransferEncoding.DEFAULT);
private final Map<String,ContentHeader> headers;
public ContentHeadersImpl(Map<String,ContentHeader> headers) {
if (headers == null) {
this.headers = EMPTY_HEADERS;
} else {
this.headers = headers;
}
}
public ContentHeadersImpl() {
this(EMPTY_HEADERS);
}
private ContentHeader get(RFC2045 key) {
ContentHeader value = headers.get(key.getName());
if (value == null) {
value = DEFAULT_HEADERS.get(key.getName());
}
return value;
}
public String getContentType() {
ContentHeader ch = get(RFC2045.CONTENT_TYPE);
// TODO: Encapsulate this.
return ch.getType() + "/" + ch.getSubType();
}
public String toString() {
Collection<String> lines = new ArrayList<String>();
for (ContentHeader h : headers.values()) {
lines.add(h.toString());
}
if (lines.size() > 0) {
lines.add("");
}
return Strings.join(lines, "\r\n");
}
public String getBoundary() {
ContentType contentType = (ContentType) get(RFC2045.CONTENT_TYPE);
if (contentType != null) {
return contentType.getBoundary();
} else {
return null;
}
}
}
|
zzuoqiang-teremail
|
teremail-core/src/main/java/org/teremail/message/ContentHeadersImpl.java
|
Java
|
lgpl
| 2,202
|
package org.teremail.message;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import org.teremail.MailSystemException;
import org.teremail.panto.ContentType;
import org.teremail.panto.ParseException;
import org.teremail.store.Strings;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.Iterators;
import com.google.common.collect.ListMultimap;
import com.google.common.collect.Multimaps;
public class MessageHeadersImpl implements MessageHeaders {
private final List<Header> returnPath;
private final List<Header> received;
private final ListMultimap<String, Header> headers;
private final static List<Header> EMPTY_HEADER = ImmutableList.of();
public MessageHeadersImpl(Header returnPath, Collection<Header> received,
ListMultimap<String, Header> headers) {
if (returnPath != null) {
this.returnPath = ImmutableList.of(returnPath);
} else {
this.returnPath = ImmutableList.of();
}
this.received = ImmutableList.copyOf(received);
this.headers = Multimaps.unmodifiableListMultimap(headers);
}
public MessageHeadersImpl(ListMultimap<String, Header> h) {
this(null, EMPTY_HEADER, h);
}
public String getSubject() {
return getString(RFC2822.SUBJECT);
}
public String getTo() {
return getString(RFC2822.TO);
}
public String getFrom() {
return getString(RFC2822.FROM);
}
public String getReturnPath() {
return getString(RFC2822.RETURN_PATH);
}
public String getDate() {
return getString(RFC2822.DATE);
}
public String getString(RFC2822 name) {
return getString(name.getName());
}
public String getString(String name) {
Header header = getHeader(name);
if (header == null) {
return null;
} else {
return header.getValue();
}
}
private Header getHeader(String key) {
Collection<Header> headers = getHeaders(key);
if (headers.size() == 0) {
return null;
} else {
return headers.iterator().next();
}
}
private Collection<Header> getHeaders(String key) {
if (RFC2822.RETURN_PATH.getName().equalsIgnoreCase(key)) {
return returnPath;
} else if (RFC2822.RECEIVED.getName().equalsIgnoreCase(key)) {
return received;
} else {
return headers.get(key.toLowerCase());
}
}
public String getBoundary() {
Header contentTypeHeader = getHeader(RFC2045.CONTENT_TYPE.getName());
if (contentTypeHeader != null) {
try {
ContentType contentType = ContentType.parse(contentTypeHeader.toString());
return contentType.getBoundary();
} catch (ParseException e) {
throw new MailSystemException("Invalid Content-Type header", e);
}
} else {
throw new MailSystemException("No Content-Type header found");
}
}
public Iterator<Header> iterator() {
return Iterators.concat(returnPath.iterator(),
received.iterator(),
headers.values().iterator());
}
public String toString() {
return Strings.join(this, "\r\n");
}
}
|
zzuoqiang-teremail
|
teremail-core/src/main/java/org/teremail/message/MessageHeadersImpl.java
|
Java
|
lgpl
| 3,421
|
package org.teremail.message;
public interface Multipart extends Entity, Iterable<Entity> {
public String getPreamble();
public String getEpilogue();
}
|
zzuoqiang-teremail
|
teremail-core/src/main/java/org/teremail/message/Multipart.java
|
Java
|
lgpl
| 168
|
package org.teremail.message;
public final class Header {
private final String name;
private final String value;
public Header(String name, String value) {
this.name = name;
this.value = value;
}
public String getName() {
return name;
}
public String getValue() {
return value;
}
public String toString() {
return name + ": " + value;
}
}
|
zzuoqiang-teremail
|
teremail-core/src/main/java/org/teremail/message/Header.java
|
Java
|
lgpl
| 430
|
package org.teremail.message;
public interface Entity {
String UNSAVED_ID = "";
public ContentHeaders getContentHeader();
public void accept(EntityVisitor v);
public String getId();
public EntityType getType();
}
|
zzuoqiang-teremail
|
teremail-core/src/main/java/org/teremail/message/Entity.java
|
Java
|
lgpl
| 248
|
/**
*
*/
package org.teremail.message;
public enum RFC2045 {
CONTENT_TYPE("Content-Type"),
CONTENT_DISPOSITION("Content-Disposition"),
CONTENT_TRANSFER_ENCODING("Content-Transfer-Encoding");
private final String name;
RFC2045(String name) {
this.name = name;
}
public String getName() {
return name;
}
}
|
zzuoqiang-teremail
|
teremail-core/src/main/java/org/teremail/message/RFC2045.java
|
Java
|
lgpl
| 366
|
package org.teremail.message;
public class AddressFormatException extends Exception {
private static final long serialVersionUID = 1L;
public AddressFormatException(String message) {
super(message);
}
}
|
zzuoqiang-teremail
|
teremail-core/src/main/java/org/teremail/message/AddressFormatException.java
|
Java
|
lgpl
| 227
|
package org.teremail.message;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.nio.charset.Charset;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import org.teremail.util.IO;
public class MemoryContentStore implements ContentStore {
private volatile long currentId = 1;
private final Map<String,byte[]> data = new ConcurrentHashMap<String,byte[]>();
public Content create(InputStream in) throws IOException {
ByteArrayOutputStream out = new ByteArrayOutputStream();
IO.copy(in, out);
String id = String.valueOf(++currentId);
data.put(id, out.toByteArray());
return new Content(id);
}
public InputStream getInputStream(Content c) {
if (data.containsKey(c.getId())) {
return new ByteArrayInputStream(data.get(c.getId()));
} else {
throw new RuntimeException("Id not found: " + c.getId());
}
}
public Content create(String text, Charset encoding) throws IOException {
return create(new ByteArrayInputStream(text.getBytes(encoding)));
}
}
|
zzuoqiang-teremail
|
teremail-core/src/main/java/org/teremail/message/MemoryContentStore.java
|
Java
|
lgpl
| 1,192
|
package org.teremail.message;
import java.nio.charset.Charset;
public final class Constants {
private Constants() {}
public final static Charset DEFAULT_ENCODING = Charset.forName("US-ASCII");
}
|
zzuoqiang-teremail
|
teremail-core/src/main/java/org/teremail/message/Constants.java
|
Java
|
lgpl
| 212
|
package org.teremail.message;
import java.io.IOException;
import java.io.InputStream;
import java.nio.charset.Charset;
public interface ContentStore {
Content create(InputStream in) throws IOException;
InputStream getInputStream(Content c);
Content create(String text, Charset encoding) throws IOException;
}
|
zzuoqiang-teremail
|
teremail-core/src/main/java/org/teremail/message/ContentStore.java
|
Java
|
lgpl
| 327
|
package org.teremail.message;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;
public class MultipartMessage implements Multipart, Message {
private final ContentHeaders contentHeader;
private final String preamble;
private final String epilogue;
private final MessageHeaders messageHeader;
private final List<Entity> parts;
private final String id;
public MultipartMessage(String id, ContentHeaders contentHeader,
MessageHeaders header, String preamble, List<Entity> parts,
String epilogue) {
this.id = id;
this.contentHeader = contentHeader;
this.messageHeader = header;
this.preamble = preamble;
this.epilogue = epilogue;
this.parts = Collections.unmodifiableList(parts);
}
public MultipartMessage(ContentHeaders contentHeader, MessageHeaders header,
String preamble, List<Entity> parts, String epilogue) {
this(Entity.UNSAVED_ID, contentHeader, header, preamble, parts, epilogue);
}
public String getId() {
return id;
}
public ContentHeaders getContentHeader() {
return contentHeader;
}
public String getEpilogue() {
return epilogue;
}
public String getPreamble() {
return preamble;
}
public MessageHeaders getHeader() {
return messageHeader;
}
public Iterator<Entity> iterator() {
return parts.iterator();
}
public void accept(EntityVisitor v) {
v.visitMultipartMessage(this);
}
public EntityType getType() {
return EntityType.MULTIPART_MESSAGE;
}
public boolean isMultipart() {
return true;
}
}
|
zzuoqiang-teremail
|
teremail-core/src/main/java/org/teremail/message/MultipartMessage.java
|
Java
|
lgpl
| 1,741
|
package org.teremail.message;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;
public class MultipartEntity implements Multipart {
private final ContentHeaders contentHeader;
private List<Entity> parts;
private final String preamble;
private final String epilogue;
private final String id;
public MultipartEntity(String id, ContentHeaders contentHeader, String preamble,
List<Entity> parts, String epilogue) {
this.id = id;
this.contentHeader = contentHeader;
this.preamble = preamble;
this.parts = Collections.unmodifiableList(parts);
this.epilogue = epilogue;
}
public MultipartEntity(ContentHeaders contentHeader, String preamble,
List<Entity> parts, String epilogue) {
this(Entity.UNSAVED_ID, contentHeader, preamble, parts, epilogue);
}
public String getId() {
return id;
}
public ContentHeaders getContentHeader() {
return contentHeader;
}
public String getEpilogue() {
return epilogue;
}
public String getPreamble() {
return preamble;
}
public Iterator<Entity> iterator() {
return parts.iterator();
}
public void accept(EntityVisitor v) {
v.visitMultipartEntity(this);
}
public EntityType getType() {
return EntityType.MULTIPART_ENTITY;
}
}
|
zzuoqiang-teremail
|
teremail-core/src/main/java/org/teremail/message/MultipartEntity.java
|
Java
|
lgpl
| 1,426
|
package org.teremail.message;
public enum EntityType {
SIMPLE_MESSAGE, MULTIPART_MESSAGE, SIMPLE_ENTITY, MULTIPART_ENTITY
}
|
zzuoqiang-teremail
|
teremail-core/src/main/java/org/teremail/message/EntityType.java
|
Java
|
lgpl
| 129
|
package org.teremail.message;
import java.util.Iterator;
public interface MessageHeaders extends Iterable<Header> {
String getSubject();
String getTo();
String getFrom();
Iterator<Header> iterator();
String getReturnPath();
String getDate();
/**
* Gets the boundary delimiter for mime messages.
* @return
*/
String getBoundary();
String getString(String s);
}
|
zzuoqiang-teremail
|
teremail-core/src/main/java/org/teremail/message/MessageHeaders.java
|
Java
|
lgpl
| 434
|
package org.teremail.message;
public class SimpleMessage implements Message, ContentEntity {
private final MessageHeaders header;
private final ContentHeaders contentHeader;
private final Content content;
private final String id;
public SimpleMessage(MessageHeaders header, ContentHeaders contentHeader, Content content) {
this(Entity.UNSAVED_ID, contentHeader, header, content);
}
public SimpleMessage(String id, ContentHeaders contentHeader,
MessageHeaders header, Content content) {
this.id = id;
this.header = header;
this.contentHeader = contentHeader;
this.content = content;
}
public ContentHeaders getContentHeader() {
return contentHeader;
}
public MessageHeaders getHeader() {
return header;
}
public Content getContent() {
return content;
}
public String getId() {
return id;
}
public EntityType getType() {
return EntityType.SIMPLE_MESSAGE;
}
public void accept(EntityVisitor v) {
v.visitSimpleMessage(this);
}
/**
* @see org.teremail.message.Message#isMultipart()
*/
public boolean isMultipart() {
String contentType = header.getString("Content-Type");
return contentType != null && contentType.startsWith("multipart/");
}
}
|
zzuoqiang-teremail
|
teremail-core/src/main/java/org/teremail/message/SimpleMessage.java
|
Java
|
lgpl
| 1,371
|
/**
*
*/
package org.teremail.provider;
import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask;
import com.google.inject.Provider;
public class FutureProvider<T> implements Provider<T> {
final FutureTask<T> future;
public FutureProvider(Callable<T> callable) {
future = new FutureTask<T>(callable);
}
public T get() {
future.run();
try {
return future.get();
} catch (Exception e) {
throw new RuntimeException(e);
}
}
}
|
zzuoqiang-teremail
|
teremail-core/src/main/java/org/teremail/provider/FutureProvider.java
|
Java
|
lgpl
| 550
|
/**
*
*/
package org.teremail.provider;
import java.util.concurrent.Callable;
import org.apache.lucene.store.Directory;
public class DirectoryProvider extends FutureProvider<Directory> {
public DirectoryProvider(Callable<Directory> callable) {
super(callable);
}
}
|
zzuoqiang-teremail
|
teremail-core/src/main/java/org/teremail/provider/DirectoryProvider.java
|
Java
|
lgpl
| 286
|
package org.teremail.provider;
import java.io.IOException;
import java.io.InputStream;
import java.util.Properties;
import com.google.inject.Provider;
import com.google.inject.ProvisionException;
public class ResourcePropertiesProvider implements Provider<Properties> {
private final String resource;
public ResourcePropertiesProvider(String resource) {
this.resource = resource;
}
@Override
public Properties get() {
try {
System.out.println("Loading Properties");
Properties properties = new Properties();
InputStream resourceAsStream = this.getClass().getClassLoader().getResourceAsStream(resource);
properties.load(resourceAsStream);
return properties;
} catch (IOException e) {
throw new ProvisionException("Failed to load properties from resource: " +
resource + " because: " + e.getMessage(), e);
}
}
}
|
zzuoqiang-teremail
|
teremail-core/src/main/java/org/teremail/provider/ResourcePropertiesProvider.java
|
Java
|
lgpl
| 970
|
/**
*
*/
package org.teremail.provider;
import java.util.concurrent.Callable;
import javax.sql.DataSource;
public class DataSourceProvider extends FutureProvider<DataSource> {
public DataSourceProvider(Callable<DataSource> callable) {
super(callable);
}
}
|
zzuoqiang-teremail
|
teremail-core/src/main/java/org/teremail/provider/DataSourceProvider.java
|
Java
|
lgpl
| 277
|
/*
* Bunisoft the Open Source Communications Company
* Copyright 2006, Bunisoft Inc., and individual contributors as
* indicated by the @authors tag. See the copyright.txt in the
* distribution for a full listing of individual contributors.
*
* This is free software; you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License as
* published by the Free Software Foundation; version 2.1 of
* the License.
*
* This software is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this software; if not, write to the Free
* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
* 02110-1301 USA, or see the FSF site: http://www.fsf.org.
*/
package org.teremail.tx;
import java.util.concurrent.Callable;
/**
* Runs transactions.
*
* @author Michael.Barker
*
*/
public interface TxRunner {
public <S> S required(Callable<S> tx);
public void required(Runnable tx);
public <S> S requiresNew(Callable<S> tx);
public void requiresNew(Runnable tx);
}
|
zzuoqiang-teremail
|
teremail-core/src/main/java/org/teremail/tx/TxRunner.java
|
Java
|
lgpl
| 1,310
|
package org.teremail.delivery;
public class NullHandler implements MessageHandler {
public void handle(Envelope envelope) {
// No-op
}
public static MessageHandler create() {
return new NullHandler();
}
}
|
zzuoqiang-teremail
|
teremail-core/src/main/java/org/teremail/delivery/NullHandler.java
|
Java
|
lgpl
| 241
|
package org.teremail.delivery;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import com.google.inject.BindingAnnotation;
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.FIELD, ElementType.PARAMETER})
@BindingAnnotation
public @interface Domains {
}
|
zzuoqiang-teremail
|
teremail-core/src/main/java/org/teremail/delivery/Domains.java
|
Java
|
lgpl
| 378
|
package org.teremail.delivery;
import java.io.ByteArrayInputStream;
import java.io.InputStream;
import java.io.SequenceInputStream;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import org.teremail.message.Entity;
import org.teremail.message.EntityVisitor;
import org.teremail.message.MessageHeaders;
import org.teremail.message.Multipart;
import org.teremail.message.MultipartEntity;
import org.teremail.message.MultipartMessage;
import org.teremail.message.SimpleEntity;
import org.teremail.message.SimpleMessage;
import org.teremail.store.Store;
import org.teremail.util.IO;
/**
* Exposes a message as an input stream.
*
* @author Michael Barker
*
*/
public class InputStreamVisitor implements EntityVisitor {
private final Store store;
private final List<InputStream> streams = new ArrayList<InputStream>();
public InputStreamVisitor(Store store) {
this.store = store;
}
private static InputStream stream(byte[] data) {
return new ByteArrayInputStream(data);
}
public InputStream getInputStream() {
return new SequenceInputStream(Collections.enumeration(streams));
}
private void visitMultipart(Multipart multipart, String boundaryStr) {
byte[] boundary = ("--" + boundaryStr).getBytes(IO.US_ASCII);
byte[] lastBoundary = ("--" + boundaryStr + "--").getBytes(IO.US_ASCII);
streams.add(stream(multipart.getPreamble().getBytes(IO.US_ASCII)));
streams.add(stream(IO.ENDL));
for (Entity e : multipart) {
streams.add(stream(boundary));
streams.add(stream(IO.ENDL));
streams.add(stream(e.getContentHeader().toString().getBytes(IO.US_ASCII)));
//streams.add(stream(IO.ENDL));
streams.add(stream(IO.ENDL));
e.accept(this);
streams.add(stream(IO.ENDL));
}
streams.add(stream(lastBoundary));
streams.add(stream(IO.ENDL));
streams.add(stream(multipart.getEpilogue().getBytes(IO.US_ASCII)));
}
public void visitMultipartEntity(MultipartEntity multipartEntity) {
String boundary = multipartEntity.getContentHeader().getBoundary();
visitMultipart(multipartEntity, boundary);
}
public void visitMultipartMessage(MultipartMessage multipartMessage) {
MessageHeaders headers = multipartMessage.getHeader();
String boundary = headers.getBoundary();
streams.add(stream(headers.toString().getBytes(IO.US_ASCII)));
streams.add(stream(IO.ENDL));
streams.add(stream(IO.ENDL));
visitMultipart(multipartMessage, boundary);
}
public void visitSimpleEntity(SimpleEntity simpleEntity) {
streams.add(store.getInputStream(simpleEntity.getContent().getId()));
}
public void visitSimpleMessage(SimpleMessage simpleMessage) {
MessageHeaders headers = simpleMessage.getHeader();
streams.add(stream(headers.toString().getBytes(IO.US_ASCII)));
streams.add(stream(IO.ENDL));
streams.add(stream(IO.ENDL));
streams.add(store.getInputStream(simpleMessage.getContent().getId()));
}
}
|
zzuoqiang-teremail
|
teremail-core/src/main/java/org/teremail/delivery/InputStreamVisitor.java
|
Java
|
lgpl
| 3,216
|
package org.teremail.delivery;
import java.io.IOException;
import java.util.concurrent.Callable;
import org.teremail.MailSystemException;
import org.teremail.message.FooContentHandler;
import org.teremail.message.Message;
import org.teremail.panto.MimeParser;
import org.teremail.store.Store;
import org.teremail.tx.TxRunner;
/**
* A message handler that parses the message into to Mime if required.
*
* @author Michael Barker
*
*/
public class MimeParserHandler implements MessageHandler {
private final Store store;
private final MessageHandler next;
private final TxRunner txr;
public MimeParserHandler(TxRunner txr, Store store, MessageHandler next) {
this.store = store;
this.next = next;
this.txr = txr;
}
public void handle(Envelope envelope) {
if (envelope.getMessage().isMultipart()) {
Message m = parseMultipart(envelope.getMessage());
next.handle(envelope.setMessage(m));
} else {
next.handle(envelope);
}
}
private Message parseMultipart(final Message message) {
return txr.required(new Callable<Message>() {
public Message call() {
FooContentHandler ch = new FooContentHandler(store);
MimeParser mp = new MimeParser();
mp.setContentHandler(ch);
InputStreamVisitor isv = new InputStreamVisitor(store);
message.accept(isv);
try {
mp.parse(isv.getInputStream());
} catch (IOException e) {
throw new MailSystemException(e);
}
return ch.getMessage();
}
});
}
}
|
zzuoqiang-teremail
|
teremail-core/src/main/java/org/teremail/delivery/MimeParserHandler.java
|
Java
|
lgpl
| 1,784
|
package org.teremail.delivery;
public interface MessageHandler {
public void handle(Envelope envelope);
}
|
zzuoqiang-teremail
|
teremail-core/src/main/java/org/teremail/delivery/MessageHandler.java
|
Java
|
lgpl
| 112
|
package org.teremail.delivery;
import java.util.Collection;
import java.util.List;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import org.teremail.common.Log;
import org.teremail.mailbox.MailboxService;
import org.teremail.mailbox.MessageDAO;
import org.teremail.message.Message;
import org.teremail.store.Store;
import com.google.common.collect.Lists;
import com.google.inject.Inject;
public class ExchangeImpl implements Exchange {
private final static Log log = Log.getLog(ExchangeImpl.class);
private final MailboxService mailboxService;
private final ExecutorService pool;
private final Store store;
private final MessageDAO messageDAO;
private MessageHandler messageHandler;
@Inject
public ExchangeImpl(MailboxService ms, MessageDAO messageDAO, Store store,
MessageHandler h) {
this.mailboxService = ms;
this.messageDAO = messageDAO;
this.store = store;
this.messageHandler = h;
pool = Executors.newFixedThreadPool(1);
}
public Collection<Future<?>> deliver(final Envelope envelope) {
final Message message = envelope.getMessage();
final Envelope savedEnvelope;
if (message.getId() == Message.UNSAVED_ID) {
Message savedMessage = (Message) messageDAO.save(message);
savedEnvelope = new Envelope(envelope.getSender(),
envelope.getRecipients(), savedMessage);
} else {
savedEnvelope = envelope;
}
log.info("Deliver sender: %s, messageId: %s",
envelope.getSender().toString(),
envelope.getMessage().getId());
List<Future<?>> futures = Lists.newArrayList();
Future<?> f = pool.submit(new Runnable() {
public void run() {
messageHandler.handle(savedEnvelope);
}
});
futures.add(f);
return futures;
}
public Store getStore() {
return store;
}
/**
* @return the mailboxService
*/
public MailboxService getMailboxService() {
return mailboxService;
}
}
|
zzuoqiang-teremail
|
teremail-core/src/main/java/org/teremail/delivery/ExchangeImpl.java
|
Java
|
lgpl
| 2,232
|
package org.teremail.delivery;
import java.util.Collection;
import org.teremail.message.Address;
import org.teremail.message.Message;
public class Envelope {
private final Address sender;
private final Collection<Address> recpts;
private final Message message;
public Envelope(Address sender, Collection<Address> recpts, Message saved) {
this.sender = sender;
this.recpts = recpts;
this.message = saved;
}
public Message getMessage() {
return message;
}
public Address getSender() {
return sender;
}
public Collection<Address> getRecipients() {
return recpts;
}
/**
* Returns a new Envelope on change of messsage.
*
* @param e
* @param m
* @return
*/
public Envelope setMessage(Message m) {
return new Envelope(getSender(), getRecipients(), m);
}
}
|
zzuoqiang-teremail
|
teremail-core/src/main/java/org/teremail/delivery/Envelope.java
|
Java
|
lgpl
| 909
|
/**
*
*/
package org.teremail.delivery;
import java.util.Properties;
import java.util.Set;
import org.teremail.mailbox.MailboxService;
import org.teremail.mailbox.search.MailboxSearch;
import org.teremail.mailbox.search.SearchIndexHandler;
import org.teremail.store.Store;
import com.google.common.collect.ImmutableSet;
import com.google.inject.Inject;
import com.google.inject.Provider;
public class MessageHandlerProvider implements Provider<MessageHandler> {
private final MessageHandler handler;
@Inject
public MessageHandlerProvider(MailboxService ms, MailboxSearch search,
Store store, Properties configuration) {
String domainsAsString = configuration.getProperty("domains", "localhost,localdomain");
Set<String> domains = ImmutableSet.of(domainsAsString.split(","));
this.handler = new SearchIndexHandler(search, store,
new DeliveryHandler(ms, domains, new NullHandler()));
}
public MessageHandler get() {
return handler;
}
}
|
zzuoqiang-teremail
|
teremail-core/src/main/java/org/teremail/delivery/MessageHandlerProvider.java
|
Java
|
lgpl
| 1,034
|
package org.teremail.delivery;
import java.util.Set;
import org.teremail.mailbox.Mailbox;
import org.teremail.mailbox.MailboxNotExistsException;
import org.teremail.mailbox.MailboxService;
import org.teremail.message.Address;
/**
* Handles the delivery of messages to their mailboxes.
*
* TODO: We need to track which messages have been delivered.
*
* @author Michael Barker
*
*/
public class DeliveryHandler implements MessageHandler {
private final MailboxService mailboxService;
private final Set<String> domains;
private final MessageHandler next;
public DeliveryHandler(MailboxService ms, Set<String> domains) {
this(ms, domains, NullHandler.create());
}
public DeliveryHandler(MailboxService ms, Set<String> domains,
MessageHandler next) {
this.mailboxService = ms;
this.domains = domains;
this.next = next;
}
public void handle(Envelope envelope) {
for (final Address recipient : envelope.getRecipients()) {
if (domains.contains(recipient.getDomain())) {
try {
Mailbox mbox = mailboxService.getMailbox(recipient.getUser());
mbox.deliver(envelope.getMessage());
} catch (MailboxNotExistsException e) {
// TODO: Bounce message.
throw new RuntimeException(e);
}
}
}
next.handle(envelope);
}
}
|
zzuoqiang-teremail
|
teremail-core/src/main/java/org/teremail/delivery/DeliveryHandler.java
|
Java
|
lgpl
| 1,479
|
package org.teremail.delivery;
import java.util.Collection;
import java.util.concurrent.Future;
import org.teremail.mailbox.MailboxService;
import org.teremail.store.Store;
public interface Exchange {
/**
* Should deliver the message to all of the appropriate recipients.
* Ideally implementations of this method should delivery asynchrounsly.
* @param newParam TODO
*/
Collection<Future<?>> deliver(Envelope newParam);
/**
* Get the store for this exchange.
*
* @return
*/
Store getStore();
MailboxService getMailboxService();
}
|
zzuoqiang-teremail
|
teremail-core/src/main/java/org/teremail/delivery/Exchange.java
|
Java
|
lgpl
| 598
|
package org.teremail.service;
public interface ServiceRegistrar {
void register(Service service);
ServiceManagerMBean createServiceManager();
}
|
zzuoqiang-teremail
|
teremail-core/src/main/java/org/teremail/service/ServiceRegistrar.java
|
Java
|
lgpl
| 154
|
package org.teremail.service;
import java.util.List;
import java.util.concurrent.CountDownLatch;
import org.teremail.common.Log;
public class ServiceManager implements ServiceManagerMBean {
private final static Log log = Log.getLog(ServiceManager.class);
private final CountDownLatch latch = new CountDownLatch(1);
private final List<Service> services;
private ServiceAction lastAction = null;
public ServiceManager(List<Service> services) {
this.services = services;
}
public void run(ServiceAction action) {
try {
if (lastAction != action) {
for (Service service : services) {
log.info("Running %s on %s", action, service.getClass().getName());
action.run(service);
}
lastAction = action;
}
} catch (Exception e) {
log.equals(e);
}
}
public void startAll() {
Runtime.getRuntime().addShutdownHook(new Thread() {
public void run() {
stopAll();
}
});
run(ServiceAction.START);
}
public void stopAll() {
try {
run(ServiceAction.STOP);
} finally {
latch.countDown();
}
}
@Override
public void bindAll() {
run(ServiceAction.BIND);
}
@Override
public void unbindAll() {
run(ServiceAction.UNBIND);
}
@Override
public void waitForShutdown() throws InterruptedException {
latch.await();
}
private enum ServiceAction {
START {
public void run(Service service) throws Exception {
service.start();
}
},
STOP {
public void run(Service service) throws Exception {
service.stop();
}
},
BIND {
public void run(Service service) throws Exception {
service.bind();
}
},
UNBIND {
public void run(Service service) throws Exception {
service.unbind();
}
};
public abstract void run(Service service) throws Exception;
}
}
|
zzuoqiang-teremail
|
teremail-core/src/main/java/org/teremail/service/ServiceManager.java
|
Java
|
lgpl
| 2,286
|
package org.teremail.service;
public interface Service {
public void start() throws Exception;
public void stop() throws Exception;
public void bind() throws Exception;
public void unbind() throws Exception;
}
|
zzuoqiang-teremail
|
teremail-core/src/main/java/org/teremail/service/Service.java
|
Java
|
lgpl
| 227
|
package org.teremail.service;
public class ServiceAdapter implements Service {
public void bind() throws Exception {
}
public void start() throws Exception {
}
public void stop() throws Exception {
}
public void unbind() throws Exception {
}
}
|
zzuoqiang-teremail
|
teremail-core/src/main/java/org/teremail/service/ServiceAdapter.java
|
Java
|
lgpl
| 282
|
package org.teremail.service;
import java.util.ArrayList;
import java.util.List;
import javax.management.MBeanServer;
import javax.management.ObjectName;
import com.google.common.collect.ImmutableList;
import com.google.inject.Inject;
public class ServiceRegistrarImpl implements ServiceRegistrar {
final List<Service> services = new ArrayList<Service>();
private final MBeanServer mbeanServer;
@Inject
public ServiceRegistrarImpl(MBeanServer mbeanServer) {
this.mbeanServer = mbeanServer;
}
public void register(Service service) {
services.add(service);
}
public ServiceManagerMBean createServiceManager() {
ServiceManager serviceManager = new ServiceManager(ImmutableList.copyOf(services));
try {
mbeanServer.registerMBean(serviceManager, new ObjectName("org.teremail", "name", "server"));
} catch (Exception e) {
throw new RuntimeException(e);
}
return serviceManager;
}
}
|
zzuoqiang-teremail
|
teremail-core/src/main/java/org/teremail/service/ServiceRegistrarImpl.java
|
Java
|
lgpl
| 1,009
|
package org.teremail.service;
public interface ServiceManagerMBean {
void startAll();
void stopAll();
void bindAll();
void unbindAll();
void waitForShutdown() throws InterruptedException;
}
|
zzuoqiang-teremail
|
teremail-core/src/main/java/org/teremail/service/ServiceManagerMBean.java
|
Java
|
lgpl
| 216
|
package org.teremail.service;
public interface Serviceable {
void registerService(ServiceRegistrar serviceRegistrar);
}
|
zzuoqiang-teremail
|
teremail-core/src/main/java/org/teremail/service/Serviceable.java
|
Java
|
lgpl
| 125
|
package org.teremail.mailbox;
import java.util.List;
import net.sf.ehcache.Cache;
import net.sf.ehcache.CacheManager;
import net.sf.ehcache.Element;
import net.sf.ehcache.config.CacheConfiguration;
import net.sf.ehcache.config.Configuration;
import org.teremail.mailbox.Folder.SortKey;
public class EhCacheMailboxDAO implements MailboxDAO {
private static final String MAILBOX_CACHE_NAME = "mailbox";
private final MailboxDAO mailboxDAO;
private final Cache cache;
private final CacheManager cacheManager;
public EhCacheMailboxDAO(@Physical MailboxDAO mailboxDAO, int maxCacheElements, int timeToLive) {
this.mailboxDAO = mailboxDAO;
cache = new Cache(MAILBOX_CACHE_NAME, maxCacheElements, false, false, timeToLive, timeToLive);
Configuration configuration = new Configuration();
CacheConfiguration cacheConfiguration = new CacheConfiguration();
cacheConfiguration.setOverflowToDisk(false);
cacheConfiguration.setDiskPersistent(false);
configuration.setDefaultCacheConfiguration(cacheConfiguration);
cacheManager = new CacheManager(configuration);
cacheManager.addCache(cache);
}
public void addMessage(FolderDO fdo, String messageId)
throws FolderNotExistsException {
mailboxDAO.addMessage(fdo, messageId);
}
public MailboxDO create(String user) throws MailboxExistsException {
MailboxDO mailbox = mailboxDAO.create(user);
cache.put(new Element(user, mailbox));
return mailbox;
}
public MailboxDO findMailbox(String user) throws MailboxNotExistsException {
Element element = cache.get(user);
MailboxDO mailbox;
if (element != null) {
mailbox = (MailboxDO) element.getObjectValue();
} else {
mailbox = mailboxDAO.findMailbox(user);
cache.put(new Element(user, mailbox));
}
return mailbox;
}
public FolderDO findFolder(MailboxDO mailbox, Path path)
throws MailboxNotExistsException, FolderNotExistsException {
String folderKey = getFolderKey(mailbox, path);
Element element = cache.get(folderKey);
FolderDO folder;
if (element != null) {
folder = (FolderDO) element.getObjectValue();
} else {
folder = mailboxDAO.findFolder(mailbox, path);
cache.put(new Element(folderKey, folder));
}
return folder;
}
public List<EntryDO> getEntries(FolderDO fdo, int pageNo, int pageSize,
SortKey... keys) {
return mailboxDAO.getEntries(fdo, pageNo, pageSize, keys);
}
public List<EntryDO> getEntries(FolderDO f) {
return mailboxDAO.getEntries(f);
}
public EntryDO getEntry(FolderDO folder, int uid)
throws EntryNotExistsException {
return mailboxDAO.getEntry(folder, uid);
}
public List<FolderDO> getFolders(MailboxDO mailbox, Path root) {
return mailboxDAO.getFolders(mailbox, root);
}
public void remove(MailboxDO mailbox, Path path)
throws MailboxNotExistsException, FolderNotExistsException {
cache.remove(getFolderKey(mailbox, path));
mailboxDAO.remove(mailbox, path);
}
public void renameFolder(MailboxDO mailbox, Path fromPath, Path toPath)
throws MailboxNotExistsException, FolderExistsException,
FolderNotExistsException {
cache.remove(getFolderKey(mailbox, fromPath));
mailboxDAO.renameFolder(mailbox, fromPath, toPath);
}
public FolderDO save(FolderDO inbox) throws FolderExistsException {
FolderDO saved = mailboxDAO.save(inbox);
String key = getFolderKey(saved);
cache.put(new Element(key, saved));
return saved;
}
private static String getFolderKey(FolderDO f) {
return getFolderKey(f.getMailbox(), f.getPath());
}
private static String getFolderKey(MailboxDO m, Path p) {
return m.getId() + ":" + p;
}
public void start() throws Exception {
}
public void stop() throws Exception {
}
}
|
zzuoqiang-teremail
|
teremail-core/src/main/java/org/teremail/mailbox/EhCacheMailboxDAO.java
|
Java
|
lgpl
| 4,188
|
package org.teremail.mailbox;
import java.util.Collection;
import java.util.Map;
import org.teremail.message.Entity;
import org.teremail.message.Message;
/**
* Data Access Layer object for entities. Entities are designed to be
* immutable, so only save and get methods are provided, no methods for
* updating will be supplied.
*
* @author Michael Barker.
*
*/
public interface MessageDAO {
/**
* Saves an entity. Entities are immutable, therefore if an Entity that
* has already been saved is passed to this method, then nothing will
* happen. I.e. an entity will only be written if <code>entity.getId() ==
* Entity.UNSAVED_VALUE</code>
*
* @param message
* @return
*/
Entity save(Entity entity);
/**
* Loads a message by id. This should load all part of the particular
* message.
*
* @param id
* @return
*/
Entity load(String id);
/**
* Loads a collection of messages according to message id. The result
* should be all of the messages indexed by id.
*
* @param ids
* @return
*/
Map<String,Entity> load(Collection<String> ids);
/**
* Loads a collection of messages according to message id. The result
* should be all of the messages indexed by id.
*
* @param ids
* @return
*/
Map<String,Message> loadMessages(Collection<String> ids);
Message loadMessage(String messageId);
}
|
zzuoqiang-teremail
|
teremail-core/src/main/java/org/teremail/mailbox/MessageDAO.java
|
Java
|
lgpl
| 1,470
|
package org.teremail.mailbox;
import java.util.List;
/**
* Proxy to a real folder object.
*
* @author Michael Barker
*
*/
public class FolderProxy implements Folder {
private final MailboxServiceImpl service;
private final FolderDO folder;
public FolderProxy(MailboxServiceImpl service, FolderDO folder) {
this.service = service;
this.folder = folder;
}
/**
* Gets the short name of this folder
*/
public String getName() {
return folder.getName();
}
/**
* Gets the full path name of this folder
*/
public Path getPath() {
return folder.getPath();
}
public List<FolderEntry> getFolderEntries(int pageNo, int pageSize, SortKey...sortKeys) {
return service.getFolderEntries(folder, pageNo, pageSize, sortKeys);
}
public FolderEntry getMessage(int uid) throws EntryNotExistsException {
return service.getFolderEntry(folder, uid);
}
}
|
zzuoqiang-teremail
|
teremail-core/src/main/java/org/teremail/mailbox/FolderProxy.java
|
Java
|
lgpl
| 974
|
package org.teremail.mailbox;
public class FolderNotExistsException extends Exception {
private static final long serialVersionUID = 1L;
private final static String FMT = "Folder: %s does not exists for User: %s";
public FolderNotExistsException(String user, String path) {
super(String.format(FMT, path, user));
}
}
|
zzuoqiang-teremail
|
teremail-core/src/main/java/org/teremail/mailbox/FolderNotExistsException.java
|
Java
|
lgpl
| 345
|
package org.teremail.mailbox.search;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import org.apache.lucene.analysis.SimpleAnalyzer;
import org.apache.lucene.document.Document;
import org.apache.lucene.document.Field;
import org.apache.lucene.index.CorruptIndexException;
import org.apache.lucene.index.IndexReader;
import org.apache.lucene.index.IndexWriter;
import org.apache.lucene.index.Term;
import org.apache.lucene.search.BooleanQuery;
import org.apache.lucene.search.Hit;
import org.apache.lucene.search.Hits;
import org.apache.lucene.search.IndexSearcher;
import org.apache.lucene.search.Query;
import org.apache.lucene.search.TermQuery;
import org.apache.lucene.search.WildcardQuery;
import org.apache.lucene.search.BooleanClause.Occur;
import org.apache.lucene.search.spans.SpanOrQuery;
import org.apache.lucene.search.spans.SpanQuery;
import org.apache.lucene.search.spans.SpanTermQuery;
import org.apache.lucene.store.Directory;
import org.teremail.MailSystemException;
import org.teremail.mailbox.EntryDO;
import org.teremail.mailbox.FolderDO;
import org.teremail.mailbox.Logical;
import org.teremail.mailbox.MailboxDAO;
import org.teremail.message.Content;
import org.teremail.message.EntityVisitorAdaptor;
import org.teremail.message.Header;
import org.teremail.message.Message;
import org.teremail.message.SimpleEntity;
import org.teremail.message.SimpleMessage;
import org.teremail.store.Store;
import com.google.inject.Inject;
/**
* Lucene based search implementation.
*
* @author mike
*
*/
public class LuceneMailboxSearch implements MailboxSearch {
private final MailboxDAO mailboxDAO;
private final Directory dir;
private final static String ID_FIELD = "id";
private final static String BODY_FIELD = "body";
@Inject
public LuceneMailboxSearch(@Logical MailboxDAO mailboxDAO, Directory dir) {
this.mailboxDAO = mailboxDAO;
this.dir = dir;
}
/**
* Walk a search term structure and build a list of query objects to
* be used to query the index.
*
* @param st
* @return
*/
private static List<Query> getTerms(SearchTerm st) {
final List<Query> tqs = new ArrayList<Query>();
SearchTermVisitor v = new SearchTermVisitor() {
public void visitBody(String key) {
tqs.add(new TermQuery(new Term(BODY_FIELD, key)));
}
public void visitHeader(String name, String value) {
tqs.add(new WildcardQuery(new Term(name, "*" + value + "*")));
}
};
st.accept(v);
return tqs;
}
/**
* Searches the specified folder using the supplied search term. Will first
* require a DB query to fetch a list of the message ids in the folder, then
* will use those as part of the query to the index.
*/
public Collection<EntryDO> search(FolderDO f, SearchTerm st) {
List<EntryDO> entries = mailboxDAO.getEntries(f);
Map<String,EntryDO> id2uidMap = new HashMap<String,EntryDO>(entries.size());
SpanQuery[] sqs = new SpanQuery[entries.size()];
int i = 0;
for (EntryDO entry : entries) {
sqs[i] = new SpanTermQuery(new Term(ID_FIELD, entry.getMessageId()));
id2uidMap.put(entry.getMessageId(), entry);
i++;
}
Query idQ = new SpanOrQuery(sqs);
BooleanQuery q = new BooleanQuery();
q.add(idQ, Occur.MUST);
for (Query query : getTerms(st)) {
q.add(query, Occur.MUST);
}
Set<EntryDO> results = new HashSet<EntryDO>();
IndexReader r = null;
try {
r = IndexReader.open(dir);
IndexSearcher s = new IndexSearcher(r);
Hits hits = s.search(q);
for (Iterator<?> it = hits.iterator(); it.hasNext();) {
Hit hit = (Hit) it.next();
String id = hit.get(ID_FIELD);
EntryDO edo = id2uidMap.get(id);
if (edo != null) {
results.add(edo);
}
}
} catch (CorruptIndexException e) {
throw new MailSystemException(e);
} catch (IOException e) {
throw new MailSystemException(e);
} finally {
if (r != null) {
try {
r.close();
} catch (IOException e) {}
}
}
return results;
}
/**
* Add the message to the index.
*/
public void index(Message message, Store store) {
final List<Content> content = new ArrayList<Content>();
message.accept(new EntityVisitorAdaptor() {
public void visitSimpleEntity(SimpleEntity simpleEntity) {
content.add(simpleEntity.getContent());
}
public void visitSimpleMessage(SimpleMessage simpleMessage) {
content.add(simpleMessage.getContent());
}
});
IndexWriter writer = null;
try {
writer = new IndexWriter(dir, new SimpleAnalyzer());
Document d = new Document();
d.add(new Field(ID_FIELD, message.getId(), Field.Store.YES,
Field.Index.UN_TOKENIZED));
for (Header header : message.getHeader()) {
d.add(new Field(header.getName().toLowerCase(),
header.getValue().toLowerCase(), Field.Store.NO,
Field.Index.UN_TOKENIZED));
}
for (Content c : content) {
InputStreamReader r =
new InputStreamReader(store.getInputStream(c.getId()));
d.add(new Field(BODY_FIELD, r));
}
writer.addDocument(d);
} catch (Exception e) {
throw new MailSystemException(e);
} finally {
if (writer != null) {
try {
writer.close();
} catch (IOException e) {}
}
}
}
}
|
zzuoqiang-teremail
|
teremail-core/src/main/java/org/teremail/mailbox/search/LuceneMailboxSearch.java
|
Java
|
lgpl
| 6,429
|
package org.teremail.mailbox.search;
import java.util.Collection;
import org.teremail.mailbox.EntryDO;
import org.teremail.mailbox.FolderDO;
import org.teremail.message.Message;
import org.teremail.store.Store;
public interface MailboxSearch {
Collection<EntryDO> search(FolderDO f, SearchTerm st);
void index(Message message, Store store);
}
|
zzuoqiang-teremail
|
teremail-core/src/main/java/org/teremail/mailbox/search/MailboxSearch.java
|
Java
|
lgpl
| 357
|
package org.teremail.mailbox.search;
public interface SearchTerm {
public void accept(SearchTermVisitor v);
}
|
zzuoqiang-teremail
|
teremail-core/src/main/java/org/teremail/mailbox/search/SearchTerm.java
|
Java
|
lgpl
| 116
|
/**
*
*/
package org.teremail.mailbox.search;
public class BodySearchTerm implements SearchTerm {
private final String key;
public BodySearchTerm(String key) {
this.key = key;
}
public void accept(SearchTermVisitor v) {
v.visitBody(key);
}
}
|
zzuoqiang-teremail
|
teremail-core/src/main/java/org/teremail/mailbox/search/BodySearchTerm.java
|
Java
|
lgpl
| 287
|
package org.teremail.mailbox.search;
/**
* Allows for independent search implementations to access the hierachy of a
* search term.
*
* @author Michael Barker
*
*/
public interface SearchTermVisitor {
void visitBody(String key);
void visitHeader(String name, String value);
}
|
zzuoqiang-teremail
|
teremail-core/src/main/java/org/teremail/mailbox/search/SearchTermVisitor.java
|
Java
|
lgpl
| 294
|
package org.teremail.mailbox.search;
import org.teremail.delivery.Envelope;
import org.teremail.delivery.MessageHandler;
import org.teremail.store.Store;
/**
* A message handler that will index the message passed to it.
*
* @author Michael Barker
*
*/
public class SearchIndexHandler implements MessageHandler {
private final MailboxSearch search;
private final MessageHandler next;
private final Store store;
public SearchIndexHandler(MailboxSearch search, Store store,
MessageHandler next) {
this.search = search;
this.next = next;
this.store = store;
}
public void handle(Envelope envelope) {
search.index(envelope.getMessage(), store);
next.handle(envelope);
}
}
|
zzuoqiang-teremail
|
teremail-core/src/main/java/org/teremail/mailbox/search/SearchIndexHandler.java
|
Java
|
lgpl
| 764
|
package org.teremail.mailbox.search;
public class HeaderSearchTerm implements SearchTerm {
private final String name;
private final String value;
public HeaderSearchTerm(String name, String value) {
this.name = name;
this.value = value;
}
public void accept(SearchTermVisitor v) {
v.visitHeader(name, value);
}
}
|
zzuoqiang-teremail
|
teremail-core/src/main/java/org/teremail/mailbox/search/HeaderSearchTerm.java
|
Java
|
lgpl
| 366
|
package org.teremail.mailbox.search;
public class SearchTerms {
public static SearchTerm body(String key) {
return new BodySearchTerm(key);
}
public static SearchTerm header(String name, String value) {
return new HeaderSearchTerm(name, value);
}
}
|
zzuoqiang-teremail
|
teremail-core/src/main/java/org/teremail/mailbox/search/SearchTerms.java
|
Java
|
lgpl
| 285
|
package org.teremail.mailbox;
public class MailboxNotExistsException extends Exception {
private static final long serialVersionUID = 1L;
public MailboxNotExistsException(String user) {
super("Mailbox does not exist for user: " + user);
}
}
|
zzuoqiang-teremail
|
teremail-core/src/main/java/org/teremail/mailbox/MailboxNotExistsException.java
|
Java
|
lgpl
| 265
|
package org.teremail.mailbox;
import static com.google.common.collect.Maps.newHashMap;
import static java.util.Arrays.asList;
import static java.util.Collections.unmodifiableMap;
import static org.teremail.schema.DBTypes.INT4;
import static org.teremail.schema.DBTypes.TIMESTAMP;
import static org.teremail.schema.DBTypes.VARCHAR;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Timestamp;
import java.sql.Types;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Date;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.UUID;
import javax.sql.DataSource;
import org.teremail.common.Log;
import org.teremail.message.Content;
import org.teremail.message.ContentHeaders;
import org.teremail.message.Entity;
import org.teremail.message.EntityType;
import org.teremail.message.EntityVisitor;
import org.teremail.message.Message;
import org.teremail.message.MessageHeaders;
import org.teremail.message.MultipartEntity;
import org.teremail.message.MultipartMessage;
import org.teremail.message.SimpleEntity;
import org.teremail.message.SimpleMessage;
import org.teremail.message.builder.Builders;
import org.teremail.message.builder.EntityBuilder;
import org.teremail.message.builder.MultipartBuilder;
import org.teremail.message.builder.MultipartEntityBuilder;
import org.teremail.message.builder.MultipartMessageBuilder;
import org.teremail.message.builder.SimpleEntityBuilder;
import org.teremail.message.builder.SimpleMessageBuilder;
import org.teremail.schema.Dialect;
import org.teremail.schema.Schema;
import org.teremail.schema.Table;
import org.teremail.schema.TableBuilder;
import org.teremail.service.Serviceable;
import org.teremail.service.ServiceAdapter;
import org.teremail.service.ServiceRegistrar;
import org.teremail.util.DB;
import org.teremail.util.Formats;
import com.google.common.base.Joiner;
import com.google.common.collect.ArrayListMultimap;
import com.google.common.collect.Multimap;
import com.google.inject.Inject;
/**
* Database based implementation of the MessageDAO. It will store a message
* and all of its parts in a single table. The table will use the EntityType
* enum to discriminate between entities of different types.
*
* @author Michael Barker
*
*/
public class DBMessageDAO implements MessageDAO, Serviceable {
private final static Log log = Log.getLog(DBMessageDAO.class);
private final static String UNSPECIFIED = null;
public final static Table ENTITY_TABLE;
static {
TableBuilder entityB = new TableBuilder("ENTITY");
entityB.column("ID", VARCHAR(40)).primaryKey();
entityB.column("TYPE", VARCHAR(20));
entityB.column("CONTENT_HEADERS", VARCHAR(8192)).nullable(true);
entityB.column("MESSAGE_HEADERS", VARCHAR(10000)).nullable(true);
entityB.column("CONTENT_ID", VARCHAR(40)).nullable(true);
entityB.column("PARENT_ID", VARCHAR(40));
entityB.column("ROOT_ID", VARCHAR(40));
entityB.column("PART_IDX", INT4());
entityB.column("SUBJECT", VARCHAR(255)).nullable(true);
entityB.column("FROM_ADDRESS", VARCHAR(255)).nullable(true);
entityB.column("SENT_DATE", TIMESTAMP()).nullable(true);
ENTITY_TABLE = entityB.build();
}
private final DataSource ds;
private final Dialect dialect;
@Inject
public DBMessageDAO(DataSource dataSource, Dialect dialect) {
this.ds = dataSource;
this.dialect = dialect;
}
public Entity save(Entity entity) {
SaveVisitor sv = new SaveVisitor();
entity.accept(sv);
return sv.getEntityBuilder().build();
}
private class SaveVisitor implements EntityVisitor {
private final String rootId;
private final String parentId;
private EntityBuilder entityBuilder = null;
private final int partIdx;
public SaveVisitor(String parentId, String rootId, int partIdx) {
this.parentId = parentId;
this.rootId = rootId;
this.partIdx = partIdx;
}
public SaveVisitor() {
this(UNSPECIFIED, UNSPECIFIED, 0);
}
public EntityBuilder getEntityBuilder() {
return entityBuilder;
}
public void visitMultipartEntity(MultipartEntity entity) {
try {
String id = UUID.randomUUID().toString();
String parentId = this.parentId != UNSPECIFIED ? this.parentId : id;
String rootId = this.rootId != UNSPECIFIED ? this.rootId : id;
insert(id, entity.getType().toString(),
entity.getContentHeader(),
null, null,
parentId, rootId, partIdx);
MultipartEntityBuilder meb = Builders.create(entity);
meb.setId(id);
meb.clearParts();
int partIdx = 0;
for (Entity e : entity) {
SaveVisitor sv = new SaveVisitor(parentId, rootId, partIdx++);
e.accept(sv);
meb.addEntityBuilder(sv.getEntityBuilder());
}
entityBuilder = meb;
} catch (SQLException e) {
throw new RuntimeException(e);
}
}
public void visitMultipartMessage(MultipartMessage message) {
try {
String id = UUID.randomUUID().toString();
String parentId = this.parentId != UNSPECIFIED ? this.parentId : id;
String rootId = this.rootId != UNSPECIFIED ? this.rootId : id;
insert(id, message.getType().toString(),
message.getContentHeader(),
message.getHeader(), null,
parentId, rootId, partIdx);
MultipartMessageBuilder mmb = Builders.create(message);
mmb.setId(id);
mmb.clearParts();
int partIdx = 0;
for (Entity e : message) {
SaveVisitor sv = new SaveVisitor(parentId, rootId, partIdx++);
e.accept(sv);
mmb.addEntityBuilder(sv.getEntityBuilder());
}
entityBuilder = mmb;
} catch (SQLException e) {
throw new RuntimeException(e);
}
}
public void visitSimpleEntity(SimpleEntity entity) {
try {
String id = UUID.randomUUID().toString();
String parentId = this.parentId != UNSPECIFIED ? this.parentId : id;
String rootId = this.rootId != UNSPECIFIED ? this.rootId : id;
insert(id, entity.getType().toString(),
entity.getContentHeader(), null,
entity.getContent().getId(),
parentId, rootId, partIdx);
SimpleEntityBuilder seb = Builders.create(entity);
seb.setId(id);
entityBuilder = seb;
} catch (SQLException e) {
throw new RuntimeException(e);
}
}
public void visitSimpleMessage(SimpleMessage message) {
try {
String id = UUID.randomUUID().toString();
String parentId = this.parentId != UNSPECIFIED ? this.parentId : id;
String rootId = this.rootId != UNSPECIFIED ? this.rootId : id;
insert(id, message.getType().toString(),
message.getContentHeader(),
message.getHeader(), message.getContent().getId(),
parentId, rootId, partIdx);
SimpleMessageBuilder smb = Builders.create(message);
smb.setId(id);
entityBuilder = smb;
} catch (SQLException e) {
throw new RuntimeException(e);
}
}
}
/**
* Inserts an entity of any type
*
* @param id Primary Key.
* @param type The type of the entity being inserted.
* @param contentHeaders The ContentHeaders (may be null)
* @param messageHeaders The MessageHeaders (may be null)
* @param contentId The contentId, may be -1 to indicate NULL
* @param parentId The parentId, will be the same as id if this object is
* the root entity.
* @param rootId The root message id.
*
* @throws SQLException
*/
private void insert(String id, String type, ContentHeaders contentHeaders,
MessageHeaders messageHeaders, String contentId, String parentId,
String rootId, int partIdx) throws SQLException {
Connection cn = null;
PreparedStatement ps = null;
try {
log.debug("SQL: %s", getInsertStatement());
cn = ds.getConnection();
ps = cn.prepareStatement(getInsertStatement());
ps.setString(1, id);
ps.setString(2, type);
setString(ps, 3, contentHeaders);
setString(ps, 4, messageHeaders);
setString(ps, 5, contentId);
ps.setString(6, parentId);
ps.setString(7, rootId);
ps.setInt(8, partIdx);
if (messageHeaders != null) {
ps.setString(9, messageHeaders.getSubject());
ps.setString(10, messageHeaders.getFrom());
Date d;
try {
d = Formats.parseSMTPDate(messageHeaders.getDate());
} catch (Exception e) {
d = new Date();
}
ps.setTimestamp(11, new Timestamp(d.getTime()));
} else {
ps.setNull(9, Types.VARCHAR);
ps.setNull(10, Types.VARCHAR);
ps.setNull(11, Types.TIMESTAMP);
}
ps.executeUpdate();
} finally {
DB.close(ps, cn);
}
}
/**
* Read an entityBuilder from the tuple that was read from
* the database.
*
* @param id
* @param type
* @param contentHeaders
* @param messageHeaders
* @param contentId
* @return
*/
private EntityBuilder read(String id, String type, String contentHeaders,
String messageHeaders, String contentId) {
EntityType entityType = EntityType.valueOf(type);
switch (entityType) {
case SIMPLE_MESSAGE:
SimpleMessageBuilder smb = new SimpleMessageBuilder();
smb.setId(id);
smb.setHeaders(messageHeaders);
smb.setContent(new Content(contentId));
return smb;
case SIMPLE_ENTITY:
SimpleEntityBuilder seb = new SimpleEntityBuilder();
seb.setId(id);
seb.setContent(new Content(contentId));
seb.setContentHeaders(contentHeaders);
return seb;
case MULTIPART_MESSAGE:
MultipartMessageBuilder mmb = new MultipartMessageBuilder();
mmb.setId(id);
mmb.setHeaders(messageHeaders);
mmb.setContentHeaders(contentHeaders);
return mmb;
case MULTIPART_ENTITY:
MultipartEntityBuilder meb = new MultipartEntityBuilder();
meb.setId(id);
meb.setContentHeaders(contentHeaders);
return meb;
default:
throw new RuntimeException("Unknown entity type: " + entityType);
}
}
/**
* @see org.teremail.mailbox.MessageDAO#load(java.util.Collection)
*/
public Map<String, Message> loadMessages(Collection<String> ids) {
Map<String, Entity> entities = load(ids);
Map<String, Message> messages = newHashMap();
for (Entity e : entities.values()) {
if (e instanceof Message) {
messages.put(e.getId(), (Message) e);
}
}
return unmodifiableMap(messages);
}
/**
* @see org.teremail.mailbox.MessageDAO#load(java.util.Collection)
*/
public Map<String, Entity> load(Collection<String> ids) {
Connection cn = null;
PreparedStatement ps = null;
ResultSet rs = null;
try {
cn = ds.getConnection();
ps = cn.prepareStatement(getSelectInList(ids));
int i = 1;
for (String id : ids) {
ps.setString(i++, id);
}
rs = ps.executeQuery();
Multimap<String,EntityBuilder> builders = ArrayListMultimap.create();
List<EntityBuilder> roots = new ArrayList<EntityBuilder>();
Set<String> idSet = new HashSet<String>(ids);
while (rs.next()) {
String id = rs.getString(1);
String type = rs.getString(2);
String contentHeaders = rs.getString(3);
String messageHeaders = rs.getString(4);
String contentId = rs.getString(5);
String parentId = rs.getString(6);
EntityBuilder eb = read(id, type, contentHeaders,
messageHeaders, contentId);
if (idSet.contains(eb.getId())) {
// Store the root object explicitly
roots.add(eb);
} else {
// Store all other indexed by the parent id.
builders.put(parentId, eb);
}
}
Map<String,Entity> messages = newHashMap();
for (EntityBuilder root : roots) {
build(root, builders);
Entity e = root.build();
messages.put(root.getId(), e);
}
return unmodifiableMap(messages);
} catch (SQLException e) {
throw new RuntimeException(e);
} finally {
DB.close(rs, ps, cn);
}
}
public Entity load(String rootId) {
Map<String,Entity> m = load(asList(rootId));
if (!m.containsKey(rootId)) {
throw new RuntimeException("Unable to find message with id: " + rootId);
}
return m.get(rootId);
}
public Message loadMessage(String rootId) {
return (Message) load(rootId);
}
/**
* Rebuilds an entity from the flat structure into a heirachical one.
*
* @param root
* @param builders
* @return
*/
private void build(EntityBuilder parent, Multimap<String, EntityBuilder> builders) {
if (parent.isMultipart()) {
MultipartBuilder mb = (MultipartBuilder) parent;
Collection<EntityBuilder> ebs = builders.get(mb.getId());
for (EntityBuilder eb : ebs) {
build(eb, builders);
mb.addEntityBuilder(eb);
}
}
}
private static void setString(PreparedStatement ps, int idx, Object o)
throws SQLException {
if (o == null) {
ps.setNull(idx, Types.VARCHAR);
} else {
ps.setString(idx, o.toString());
}
}
private String getInsertStatement() {
return "INSERT INTO entity (id, type, content_headers, message_headers, content_id, parent_id, root_id, part_idx, subject, from_address, sent_date) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)";
}
private String getSelectInList(Collection<String> ids) {
String[] s = new String[ids.size()];
for (int i = 0; i < s.length; i++) {
s[i] = "?";
}
String in = "(" + Joiner.on(", ").join(s) + ")";
return "SELECT id," +
" type," +
" content_headers," +
" message_headers," +
" content_id," +
" parent_id," +
" root_id " +
"FROM entity " +
"WHERE root_id IN " + in + " " +
"ORDER BY part_idx";
}
// ==================
// Service Management
// ==================
public void init() {
Schema.createIfNotExists(ds, ENTITY_TABLE, dialect);
}
@Inject
public void registerService(ServiceRegistrar serviceRegistrar) {
serviceRegistrar.register(new ServiceAdapter() {
public void start() {
init();
}
});
}
}
|
zzuoqiang-teremail
|
teremail-core/src/main/java/org/teremail/mailbox/DBMessageDAO.java
|
Java
|
lgpl
| 17,031
|
package org.teremail.mailbox;
import static java.lang.Integer.parseInt;
import java.util.Properties;
import com.google.inject.Inject;
import com.google.inject.Provider;
public class EhCacheMailboxDAOProvider implements Provider<EhCacheMailboxDAO> {
private final Properties configuration;
private final MailboxDAO mailboxDAO;
@Inject
public EhCacheMailboxDAOProvider(@Physical MailboxDAO mailboxDAO, Properties configuration) {
this.mailboxDAO = mailboxDAO;
this.configuration = configuration;
}
@Override
public EhCacheMailboxDAO get() {
int maxCacheElements = parseInt(configuration.getProperty("ehcache.mailbox.maxCacheElements"));
int timeToLive = parseInt(configuration.getProperty("ehcache.mailbox.timeToLive"));
return new EhCacheMailboxDAO(mailboxDAO, maxCacheElements, timeToLive);
}
}
|
zzuoqiang-teremail
|
teremail-core/src/main/java/org/teremail/mailbox/EhCacheMailboxDAOProvider.java
|
Java
|
lgpl
| 878
|
package org.teremail.mailbox;
import java.util.ArrayList;
import java.util.List;
public class Lists {
public static <T> List<T> concat(List<? extends T>...lists) {
List<T> result = new ArrayList<T>();
for (List<? extends T> l : lists) {
result.addAll(l);
}
return result;
}
}
|
zzuoqiang-teremail
|
teremail-core/src/main/java/org/teremail/mailbox/Lists.java
|
Java
|
lgpl
| 332
|
package org.teremail.mailbox;
public class EntryNotExistsException extends Exception {
private static final long serialVersionUID = 454437929626129603L;
private final String folderId;
private final int uid;
public EntryNotExistsException(String folderId, int uid) {
super(String.format("Entry uid: %s, does not exist in folder: %d",
folderId, uid));
this.folderId = folderId;
this.uid = uid;
}
public String getFolderId() {
return folderId;
}
public int getUid() {
return uid;
}
}
|
zzuoqiang-teremail
|
teremail-core/src/main/java/org/teremail/mailbox/EntryNotExistsException.java
|
Java
|
lgpl
| 583
|
package org.teremail.mailbox;
/**
* The data object that is stored in the database.
*
* @author Michael Barker
*
*/
public class MailboxDO {
private final String user;
private final String id;
public MailboxDO(String id, String user) {
this.id = id;
this.user = user;
}
public String getId() {
return id;
}
public String getUser() {
return user;
}
}
|
zzuoqiang-teremail
|
teremail-core/src/main/java/org/teremail/mailbox/MailboxDO.java
|
Java
|
lgpl
| 430
|
package org.teremail.mailbox;
import static org.teremail.mailbox.Path.path;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import org.teremail.MailSystemException;
import org.teremail.mailbox.Folder.SortKey;
import org.teremail.message.Message;
import com.google.inject.Inject;
public class MailboxServiceImpl implements MailboxService {
private final MailboxDAO mailboxDAO;
private final MessageDAO messageDAO;
@Inject
public MailboxServiceImpl(@Logical MailboxDAO mailboxDAO, MessageDAO messageDAO) {
this.mailboxDAO = mailboxDAO;
this.messageDAO = messageDAO;
}
public Mailbox create(String user) throws MailboxExistsException {
MailboxDO mailbox = mailboxDAO.create(user);
FolderDO inbox = new FolderDO(path("INBOX"), mailbox);
try {
mailboxDAO.save(inbox);
} catch (FolderExistsException e) {
throw new MailSystemException(e);
}
return new MailboxProxy(this, mailbox);
}
public FolderDO getFolder(MailboxDO mailbox, Path path)
throws FolderNotExistsException, MailboxNotExistsException {
return mailboxDAO.findFolder(mailbox, path);
}
public FolderDO createFolder(MailboxDO mailbox, Path path)
throws FolderExistsException {
FolderDO folder = new FolderDO(path, mailbox);
return mailboxDAO.save(folder);
}
public void removeFolder(MailboxDO mailbox, Path path)
throws MailboxNotExistsException, FolderNotExistsException {
mailboxDAO.remove(mailbox, path);
}
public Mailbox getMailbox(String user) throws MailboxNotExistsException {
return new MailboxProxy(this, mailboxDAO.findMailbox(user));
}
public void renameFolder(MailboxDO mailbox, Path fromPath, Path toPath)
throws MailboxNotExistsException, FolderExistsException,
FolderNotExistsException {
if (fromPath.isInbox()) {
FolderDO inbox = mailboxDAO.findFolder(mailbox, Path.INBOX);
FolderDO newMailbox = new FolderDO(null, inbox);
newMailbox.setPath(toPath);
mailboxDAO.save(newMailbox);
} else {
mailboxDAO.renameFolder(mailbox, fromPath, toPath);
}
}
public void addMessage(MailboxDO mailbox, Path path, Message m)
throws FolderNotExistsException, MailboxNotExistsException {
assert m.getId() != Message.UNSAVED_ID;
FolderDO fdo = getFolder(mailbox, path);
mailboxDAO.addMessage(fdo, m.getId());
}
public List<Folder> getFolders(MailboxDO mailbox, Path basePath) {
List<Folder> f = new ArrayList<Folder>();
for (FolderDO fdo : mailboxDAO.getFolders(mailbox, basePath)) {
f.add(new FolderProxy(this, fdo));
}
return f;
}
public List<FolderEntry> getFolderEntries(FolderDO folder,
int pageNo, int pageSize, SortKey[] sortKeys) {
List<EntryDO> entries = mailboxDAO.getEntries(folder, pageNo, pageSize, sortKeys);
List<FolderEntry> result = new ArrayList<FolderEntry>(entries.size());
List<String> messageIds = new ArrayList<String>(entries.size());
for (EntryDO entryDO : entries) {
messageIds.add(entryDO.getMessageId());
}
Map<String,Message> messages = messageDAO.loadMessages(messageIds);
for (EntryDO entry : entries) {
Message m = messages.get(entry.getMessageId());
result.add(new FolderEntryProxy(entry, m));
}
return result;
}
public FolderEntry getFolderEntry(FolderDO folder, int uid) throws EntryNotExistsException {
EntryDO entry = mailboxDAO.getEntry(folder, uid);
Message m = messageDAO.loadMessage(entry.getMessageId());
return new FolderEntryProxy(entry, m);
}
public void start() throws Exception {
System.out.println("Starting Mailbox");
}
public void stop() throws Exception {
System.out.println("Stopping Mailbox");
}
}
|
zzuoqiang-teremail
|
teremail-core/src/main/java/org/teremail/mailbox/MailboxServiceImpl.java
|
Java
|
lgpl
| 4,163
|
package org.teremail.mailbox;
import java.util.List;
public interface Folder {
enum SortKey { UID, FROM, SUBJECT, DATE };
String getName();
Path getPath();
List<FolderEntry> getFolderEntries(int pageNo, int pageSize, SortKey...sortKey);
FolderEntry getMessage(int uid) throws EntryNotExistsException;
}
|
zzuoqiang-teremail
|
teremail-core/src/main/java/org/teremail/mailbox/Folder.java
|
Java
|
lgpl
| 335
|
package org.teremail.mailbox;
import static org.teremail.mailbox.Path.path;
import java.util.List;
import org.teremail.message.Message;
public class MailboxProxy implements Mailbox {
private final MailboxDO mailbox;
private final MailboxServiceImpl service;
private final Path INBOX = path("INBOX");
public MailboxProxy(MailboxServiceImpl service, MailboxDO mailbox) {
this.service = service;
this.mailbox = mailbox;
}
public Folder getFolder(Path path) throws FolderNotExistsException {
try {
return new FolderProxy(service, service.getFolder(mailbox, path));
} catch (MailboxNotExistsException e) {
// This shouldn't happen as we should have been given
// a valid maibox.
throw new RuntimeException(e);
}
}
public String getUser() {
return mailbox.getUser();
}
public Folder createFolder(Path path) throws FolderExistsException {
FolderDO folder = service.createFolder(mailbox, path);
return new FolderProxy(service, folder);
}
public void remove(Path path) throws FolderNotExistsException {
try {
service.removeFolder(mailbox, path);
} catch (MailboxNotExistsException e) {
throw new RuntimeException(e);
}
}
public void renameFolder(Path fromPath, Path toPath)
throws FolderExistsException, FolderNotExistsException {
try {
service.renameFolder(mailbox, fromPath, toPath);
} catch (MailboxNotExistsException e) {
throw new RuntimeException(e);
}
}
public void deliver(Message m) {
try {
service.addMessage(mailbox, INBOX, m);
} catch (FolderNotExistsException e) {
throw new RuntimeException(e);
} catch (MailboxNotExistsException e) {
throw new RuntimeException(e);
}
}
public List<Folder> getFolders(Path basePath) {
return service.getFolders(mailbox, basePath);
}
}
|
zzuoqiang-teremail
|
teremail-core/src/main/java/org/teremail/mailbox/MailboxProxy.java
|
Java
|
lgpl
| 2,060
|
package org.teremail.mailbox;
import static org.teremail.schema.DBTypes.INT4;
import static org.teremail.schema.DBTypes.VARCHAR;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.UUID;
import javax.sql.DataSource;
import org.teremail.common.Log;
import org.teremail.mailbox.Folder.SortKey;
import org.teremail.schema.Dialect;
import org.teremail.schema.Schema;
import org.teremail.schema.Table;
import org.teremail.schema.TableBuilder;
import org.teremail.service.Serviceable;
import org.teremail.service.ServiceAdapter;
import org.teremail.service.ServiceRegistrar;
import org.teremail.util.DB;
import com.google.common.base.Joiner;
import com.google.inject.Inject;
public class DBMailboxDAO implements MailboxDAO, Serviceable {
private static final Log log = Log.getLog(DBMailboxDAO.class);
public static final Table MAILBOX_TABLE;
public static final Table FOLDER_TABLE;
public static final Table ENTRY_TABLE;
static {
TableBuilder mailboxB = new TableBuilder("MAILBOX");
mailboxB.column("ID", VARCHAR(40)).primaryKey();
mailboxB.column("USERNAME", VARCHAR(255));
mailboxB.addUnique("USERNAME");
MAILBOX_TABLE = mailboxB.build();
TableBuilder folderB = new TableBuilder("FOLDER");
folderB.column("ID", VARCHAR(40)).primaryKey();
folderB.column("PATH", VARCHAR(255));
folderB.column("MAILBOX_ID", VARCHAR(40));
folderB.column("VERSION", INT4());
folderB.addUnique("PATH", "MAILBOX_ID");
FOLDER_TABLE = folderB.build();
TableBuilder entryB = new TableBuilder("ENTRY");
entryB.column("UID", INT4()).primaryKey();
entryB.column("FOLDER_ID", VARCHAR(40)).primaryKey();
entryB.column("MESSAGE_ID", VARCHAR(40));
ENTRY_TABLE = entryB.build();
}
private final DataSource ds;
private final Dialect dialect;
@Inject
public DBMailboxDAO(DataSource ds, Dialect dialect) {
this.ds = ds;
this.dialect = dialect;
}
public void addMessage(FolderDO fdo, String messageId) throws FolderNotExistsException {
final String insert = "INSERT INTO entry (uid, folder_id, message_id) VALUES (?, ?, ?)";
int uid = getNextUid(fdo);
Connection cn = null;
PreparedStatement ps = null;
try {
cn = ds.getConnection();
ps = cn.prepareStatement(insert);
ps.setInt(1, uid);
ps.setString(2, fdo.getId());
ps.setString(3, messageId);
ps.executeUpdate();
} catch (SQLException e) {
throw new RuntimeException(e);
} finally {
DB.close(ps, cn);
}
}
/**
* TODO: This needs to run in a seperate transaction.
*
* @param fdo
* @return
* @throws FolderNotExistsException
*/
private int getNextUid(FolderDO fdo) throws FolderNotExistsException {
final String select = "SELECT version FROM folder WHERE id = ? FOR UPDATE";
final String update = "UPDATE folder SET version = version + 1 WHERE id = ?";
Connection cn = null;
PreparedStatement psSelect = null;
PreparedStatement psUpdate = null;
ResultSet rs = null;
try {
log.debug("SQL: " + select);
int version;
cn = ds.getConnection();
psSelect = cn.prepareStatement(select);
psSelect.setString(1, fdo.getId());
rs = psSelect.executeQuery();
if (rs.next()) {
version = rs.getInt(1);
} else {
throw new FolderNotExistsException(fdo.getMailbox().getUser(), fdo.getName());
}
log.debug("SQL: " + update);
psUpdate = cn.prepareStatement(update);
psUpdate.setString(1, fdo.getId());
psUpdate.executeUpdate();
return version;
} catch (SQLException e) {
throw new RuntimeException(e);
} finally {
DB.close(rs, psSelect, null);
DB.close(psUpdate, cn);
}
}
public List<Long> getUids(FolderDO fdo) {
String select = "SELECT uid FROM entry WHERE folder_id = ?";
Connection cn = null;
PreparedStatement ps = null;
ResultSet rs = null;
try {
List<Long> uids = new ArrayList<Long>();
cn = ds.getConnection();
ps = cn.prepareStatement(select);
ps.setString(1, fdo.getId());
rs = ps.executeQuery();
while (rs.next()) {
uids.add(rs.getLong(1));
}
return uids;
} catch (SQLException e) {
throw new RuntimeException(e);
} finally {
DB.close(rs, ps, cn);
}
}
public void remove(MailboxDO mailbox, Path path)
throws MailboxNotExistsException, FolderNotExistsException {
// TODO Auto-generated method stub
}
public void renameFolder(MailboxDO mailbox, Path fromPath, Path toPath)
throws MailboxNotExistsException, FolderExistsException,
FolderNotExistsException {
// TODO Auto-generated method stub
}
public MailboxDO findMailbox(String user) throws MailboxNotExistsException {
String sql = "SELECT id, username FROM mailbox where username = ?";
Connection cn = null;
PreparedStatement ps = null;
ResultSet rs = null;
try {
log.debug("SQL %s", sql);
cn = ds.getConnection();
ps = cn.prepareStatement(sql);
ps.setString(1, user);
rs = ps.executeQuery();
if (rs.next()) {
String id = rs.getString(1);
return new MailboxDO(id, user);
} else {
throw new MailboxNotExistsException(user);
}
} catch (SQLException e) {
throw new RuntimeException(e);
} finally {
DB.close(rs, ps, cn);
}
}
public MailboxDO create(String user) throws MailboxExistsException {
String s = "INSERT INTO mailbox (id, username) VALUES (?, ?)";
Connection cn = null;
PreparedStatement ps = null;
try {
log.debug("SQL: %s", s);
cn = ds.getConnection();
ps = cn.prepareStatement(s);
String id = UUID.randomUUID().toString();
ps.setString(1, id);
ps.setString(2, user);
ps.executeUpdate();
return new MailboxDO(id, user);
} catch (SQLException e) {
if (dialect.isDuplicateKey(e.getSQLState())) {
throw new MailboxExistsException(user);
} else {
throw new RuntimeException(String.valueOf(e.getSQLState()), e);
}
} finally {
DB.close(ps, cn);
}
}
public FolderDO findFolder(MailboxDO mailbox, Path path)
throws MailboxNotExistsException, FolderNotExistsException {
String sql = "SELECT id, path FROM FOLDER WHERE mailbox_id = ? AND path = ? ";
Connection cn = null;
PreparedStatement ps = null;
ResultSet rs = null;
String user = mailbox.getUser();
String pathStr = path.toString();
try {
log.info("SQL: %s", sql);
cn = ds.getConnection();
ps = cn.prepareStatement(sql);
ps.setString(1, mailbox.getId());
ps.setString(2, pathStr);
rs = ps.executeQuery();
if (rs.next()) {
String id = rs.getString(1);
return new FolderDO(id, path, 1, mailbox);
} else {
throw new FolderNotExistsException(user, pathStr);
}
} catch (SQLException e) {
throw new RuntimeException(e);
} finally {
DB.close(rs, ps, cn);
}
}
public FolderDO save(FolderDO folder) throws FolderExistsException {
String sql = "INSERT INTO folder (id, path, version, mailbox_id) VALUES (?, ?, 1, ?)";
Connection cn = null;
PreparedStatement ps = null;
try {
log.debug("SQL: %s", sql);
cn = ds.getConnection();
ps = cn.prepareStatement(sql);
String id = UUID.randomUUID().toString();
ps.setString(1, id);
ps.setString(2, folder.getPath().toString());
ps.setString(3, folder.getMailbox().getId());
ps.executeUpdate();
return new FolderDO(id, folder);
} catch (SQLException e) {
if (dialect.isDuplicateKey(e.getSQLState())) {
throw new FolderExistsException(folder.getMailbox().getUser(),
folder.getPath().toString());
} else {
throw new RuntimeException(e);
}
} finally {
DB.close(ps, cn);
}
}
public List<FolderDO> getFolders(MailboxDO mailbox, Path root) {
String sql = "SELECT id, path, version FROM folder WHERE mailbox_id = ? AND path like ?";
String path = root.toString() + "%";
Connection cn = null;
PreparedStatement ps = null;
ResultSet rs = null;
try {
log.debug(sql);
cn = ds.getConnection();
ps = cn.prepareStatement(sql);
ps.setString(1, mailbox.getId());
ps.setString(2, path);
List<FolderDO> folders = new ArrayList<FolderDO>();
rs = ps.executeQuery();
while (rs.next()) {
String id = rs.getString(1);
Path p = Path.path(rs.getString(2));
int version = rs.getInt(3);
folders.add(new FolderDO(id, p, version, mailbox));
}
return folders;
} catch (SQLException e) {
throw new RuntimeException(e);
} finally {
DB.close(rs, ps, cn);
}
}
public List<EntryDO> getEntries(FolderDO fdo) {
Connection cn = null;
PreparedStatement ps = null;
ResultSet rs = null;
try {
String sql = "SELECT uid, message_id FROM entry WHERE folder_id = ?";
log.debug(sql);
cn = ds.getConnection();
ps = cn.prepareStatement(sql);
ps.setString(1, fdo.getId());
List<EntryDO> entries = new ArrayList<EntryDO>(128);
rs = ps.executeQuery();
while (rs.next()) {
int uid = rs.getInt(1);
String messageId = rs.getString(2);
entries.add(new EntryDO(uid, messageId));
}
return entries;
} catch (SQLException e) {
throw new RuntimeException(e);
} finally {
DB.close(rs, ps, cn);
}
}
public List<EntryDO> getEntries(FolderDO fdo, int pageNo, int pageSize, SortKey...keys) {
Connection cn = null;
PreparedStatement ps = null;
ResultSet rs = null;
String orderBy = getOrderyBy(keys);
try {
cn = ds.getConnection();
List<EntryDO> edo = new ArrayList<EntryDO>();
if (dialect.isPagingSupported()) {
String select = dialect.createPagedQuery("entry.uid, entry.message_id",
"entry JOIN entity ON entry.message_id = entity.id",
"folder_id = ?", orderBy, pageNo, pageSize);
ps = cn.prepareStatement(select);
ps.setString(1, fdo.getId());
rs = ps.executeQuery();
while (rs.next()) {
int uid = rs.getInt(1);
String messageId = rs.getString(2);
edo.add(new EntryDO(uid, messageId));
}
} else {
String select = "SELECT entry.uid, entry.message_id FROM entry JOIN entity ON entry.message_id = entity.id WHERE entry.folder_id = ? ORDER BY " + orderBy;
log.debug("SQL: %s", select);
ps = cn.prepareStatement(select);
ps.setString(1, fdo.getId());
rs = ps.executeQuery();
int i = 0;
int min = pageNo * pageSize;
int max = ((pageNo + 1) * pageSize) - 1;
while (rs.next()) {
if (i >= min && i <= max) {
int uid = rs.getInt(1);
String messageId = rs.getString(2);
edo.add(new EntryDO(uid, messageId));
} else if (i > max) {
break;
}
i++;
}
}
return Collections.unmodifiableList(edo);
} catch (SQLException e) {
throw new RuntimeException(e);
} finally {
DB.close(rs, ps, cn);
}
}
public EntryDO getEntry(FolderDO f, int uid) throws EntryNotExistsException {
Connection cn = null;
PreparedStatement ps = null;
ResultSet rs = null;
try {
cn = ds.getConnection();
ps = cn.prepareStatement("SELECT message_id FROM entry WHERE folder_id = ? AND uid = ?");
ps.setString(1, f.getId());
ps.setInt(2, uid);
rs = ps.executeQuery();
if (rs.next()) {
String messageId = rs.getString(1);
return new EntryDO(uid, messageId);
} else {
throw new EntryNotExistsException(f.getId(), uid);
}
} catch (SQLException e) {
throw new RuntimeException(e);
} finally {
DB.close(rs, ps, cn);
}
}
private String getOrderyBy(SortKey[] keys) {
if (keys.length == 0) {
return "uid";
}
String[] cols = new String[keys.length];
for (int i = 0; i < cols.length; i++) {
SortKey key = keys[i];
switch (key) {
case DATE:
cols[i] = DBMessageDAO.ENTITY_TABLE.getName() + ".SENT_DATE";
break;
case FROM:
cols[i] = DBMessageDAO.ENTITY_TABLE.getName() + ".FROM_ADDRESS";
break;
case UID:
cols[i] = ENTRY_TABLE.getName() + ".UID";
break;
default:
cols[i] = DBMessageDAO.ENTITY_TABLE.getName() + "." + key.name();
}
}
return Joiner.on(", ").join(cols);
}
public DataSource getDataSource() {
return ds;
}
// ==================
// Service Management
// ==================
public void init() {
Schema.createIfNotExists(ds, MAILBOX_TABLE, dialect);
Schema.createIfNotExists(ds, FOLDER_TABLE, dialect);
Schema.createIfNotExists(ds, ENTRY_TABLE, dialect);
}
@Inject
public void registerService(ServiceRegistrar serviceRegistrar) {
serviceRegistrar.register(new ServiceAdapter(){
@Override
public void start() throws Exception {
init();
}
});
}
}
|
zzuoqiang-teremail
|
teremail-core/src/main/java/org/teremail/mailbox/DBMailboxDAO.java
|
Java
|
lgpl
| 15,884
|
package org.teremail.mailbox;
public class FolderExistsException extends Exception {
private static final long serialVersionUID = 1L;
private final static String FMT = "Folder %s for already exists for User: %s";
public FolderExistsException(String user, String path) {
super(String.format(FMT, path, user));
}
}
|
zzuoqiang-teremail
|
teremail-core/src/main/java/org/teremail/mailbox/FolderExistsException.java
|
Java
|
lgpl
| 346
|
package org.teremail.mailbox;
import org.teremail.message.Message;
import org.teremail.message.MessageHeaders;
public interface FolderEntry {
int getUid();
MessageHeaders getMessageHeaders();
Message getMessage();
}
|
zzuoqiang-teremail
|
teremail-core/src/main/java/org/teremail/mailbox/FolderEntry.java
|
Java
|
lgpl
| 234
|
package org.teremail.mailbox;
import java.util.List;
import org.teremail.mailbox.Folder.SortKey;
/**
* Data Access interface for the mailbox. Will have some cross over with
* the MessageDAO.
*
* @author mike
*
*/
public interface MailboxDAO {
/**
* Create a mailbox for the specified user name.
*
* @param user
* @return
* @throws MailboxExistsException
*/
MailboxDO create(String user) throws MailboxExistsException;
/**
* Find a folder for the specified mailbox and path.
*
* @param mailbox
* @param path
* @return
* @throws MailboxNotExistsException
* @throws FolderNotExistsException
*/
FolderDO findFolder(MailboxDO mailbox, Path path)
throws MailboxNotExistsException, FolderNotExistsException;
/**
* Save a folder data object.
*
* @param inbox
* @return
* @throws FolderExistsException
*/
FolderDO save(FolderDO inbox) throws FolderExistsException;
void remove(MailboxDO mailbox, Path path) throws MailboxNotExistsException,
FolderNotExistsException;
MailboxDO findMailbox(String user) throws MailboxNotExistsException;
void renameFolder(MailboxDO mailbox, Path fromPath, Path toPath)
throws MailboxNotExistsException, FolderExistsException, FolderNotExistsException;
void addMessage(FolderDO fdo, String messageId) throws FolderNotExistsException;
List<FolderDO> getFolders(MailboxDO mailbox, Path root);
List<EntryDO> getEntries(FolderDO f);
List<EntryDO> getEntries(FolderDO fdo, int pageNo, int pageSize, SortKey...keys);
EntryDO getEntry(FolderDO folder, int uid) throws EntryNotExistsException;
}
|
zzuoqiang-teremail
|
teremail-core/src/main/java/org/teremail/mailbox/MailboxDAO.java
|
Java
|
lgpl
| 1,735
|
package org.teremail.mailbox;
import org.teremail.message.Message;
import org.teremail.message.MessageHeaders;
public class FolderEntryProxy implements FolderEntry {
private final EntryDO entry;
private final Message message;
public FolderEntryProxy(EntryDO entry, Message message) {
this.entry = entry;
this.message = message;
}
public Message getMessage() {
return message;
}
public MessageHeaders getMessageHeaders() {
return message.getHeader();
}
public int getUid() {
return entry.getUid();
}
}
|
zzuoqiang-teremail
|
teremail-core/src/main/java/org/teremail/mailbox/FolderEntryProxy.java
|
Java
|
lgpl
| 593
|
package org.teremail.mailbox;
import java.util.List;
import org.teremail.message.Message;
/**
* Interface for a user's mailbox.
*
* @author Michael Barker
*
*/
public interface Mailbox {
public final static String DELIM = "/";
/**
* Get a specified folder.
*
* @param path
* @return
* @throws FolderNotExistsException
*/
Folder getFolder(Path path) throws FolderNotExistsException;
String getUser();
Folder createFolder(Path path) throws FolderExistsException;
void remove(Path path) throws FolderNotExistsException;
void renameFolder(Path fromPath, Path toPath) throws FolderExistsException, FolderNotExistsException;
void deliver(Message m);
List<Folder> getFolders(Path root);
}
|
zzuoqiang-teremail
|
teremail-core/src/main/java/org/teremail/mailbox/Mailbox.java
|
Java
|
lgpl
| 771
|
package org.teremail.mailbox;
import java.util.Arrays;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;
import com.google.common.base.Joiner;
/**
* Representation of hierachical path. Takes a path as a '/' delimited
* string.
*
*/
public final class Path {
private final List<String> parts;
public final static String INBOX_NAME = "INBOX";
public final static Path INBOX = path(INBOX_NAME);
@SuppressWarnings("unchecked")
public final static Path ROOT = new Path(Collections.EMPTY_LIST);
private Path(List<String> parts) {
this.parts = Collections.unmodifiableList(parts);
}
public boolean isChildOf(Path other) {
if (parts.size() < other.parts.size()) {
return false;
}
Iterator<String> thisIt = parts.iterator();
Iterator<String> otherIt = other.parts.iterator();
while (otherIt.hasNext() && thisIt.hasNext()) {
if (!thisIt.next().equals(otherIt.next())) {
return false;
}
}
return true;
}
public List<String> getParts() {
return parts;
}
/**
* Compares the paths for equality, are equal iff the parts are the same.
*/
public boolean equals(Object o) {
if (o == null || !(o instanceof Path)) {
return false;
}
Path other = (Path) o;
if (parts.size() != other.parts.size()) {
return false;
}
Iterator<String> thisIt = parts.iterator();
Iterator<String> otherIt = other.parts.iterator();
while (otherIt.hasNext() && thisIt.hasNext()) {
if (!thisIt.next().equals(otherIt.next())) {
return false;
}
}
return true;
}
public int hashCode() {
int code = 0;
for (String part : parts) {
code += part.hashCode();
}
return code;
}
public String last() {
return parts.get(parts.size() - 1);
}
@Override
public String toString() {
return Joiner.on("/").join(parts);
}
public Path replace(Path target, Path replacement) {
Path head = new Path(parts.subList(0, target.parts.size()));
Path result;
if (head.equals(target)) {
@SuppressWarnings("unchecked")
List<String> newParts = Lists.concat(replacement.parts,
parts.subList(target.parts.size(), parts.size()));
result = new Path(newParts);
} else {
result = this;
}
return result;
}
/**
* Static create method. Handles renaming inbox to upper case.
*
* @param pathStr
* @return
*/
public static Path path(String pathStr) {
String[] pathArr = pathStr.split("/");
if (INBOX_NAME.equalsIgnoreCase(pathArr[0])) {
pathArr[0] = INBOX_NAME;
}
return new Path(Arrays.asList(pathArr));
}
public boolean isInbox() {
return INBOX_NAME.equals(parts.get(0));
}
}
|
zzuoqiang-teremail
|
teremail-core/src/main/java/org/teremail/mailbox/Path.java
|
Java
|
lgpl
| 3,183
|
package org.teremail.mailbox;
/**
* A entry for a particular message in a folder.
*
* @author Michael Barker
*
*/
public class EntryDO {
private final int uid;
private final String messageId;
public EntryDO(int uid, String messageId) {
this.uid = uid;
this.messageId = messageId;
}
/**
* @return the uid
*/
public int getUid() {
return uid;
}
/**
* @return the messageId
*/
public String getMessageId() {
return messageId;
}
/**
* @see java.lang.Object#hashCode()
*/
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result
+ ((messageId == null) ? 0 : messageId.hashCode());
result = prime * result + uid;
return result;
}
/**
* @see java.lang.Object#equals(java.lang.Object)
*/
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
final EntryDO other = (EntryDO) obj;
if (messageId == null) {
if (other.messageId != null)
return false;
} else if (!messageId.equals(other.messageId))
return false;
if (uid != other.uid)
return false;
return true;
}
}
|
zzuoqiang-teremail
|
teremail-core/src/main/java/org/teremail/mailbox/EntryDO.java
|
Java
|
lgpl
| 1,464
|
package org.teremail.mailbox;
public interface MailboxService {
Mailbox create(String user) throws MailboxExistsException;
Mailbox getMailbox(String user) throws MailboxNotExistsException;
}
|
zzuoqiang-teremail
|
teremail-core/src/main/java/org/teremail/mailbox/MailboxService.java
|
Java
|
lgpl
| 204
|
package org.teremail.mailbox;
public class MailboxExistsException extends Exception {
private static final long serialVersionUID = 1L;
public MailboxExistsException(String user) {
super("Mailbox already exists for: " + user);
}
}
|
zzuoqiang-teremail
|
teremail-core/src/main/java/org/teremail/mailbox/MailboxExistsException.java
|
Java
|
lgpl
| 262
|