You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
297 lines
9.9 KiB
297 lines
9.9 KiB
package de.anomic.data;
|
|
|
|
import java.io.IOException;
|
|
import java.net.MalformedURLException;
|
|
import java.util.HashSet;
|
|
import java.util.Iterator;
|
|
import net.yacy.cora.storage.ConcurrentARC;
|
|
import net.yacy.kelondro.blob.Tables;
|
|
import net.yacy.kelondro.blob.Tables.Data;
|
|
import net.yacy.kelondro.data.meta.DigestURI;
|
|
import net.yacy.kelondro.data.word.Word;
|
|
import net.yacy.kelondro.index.RowSpaceExceededException;
|
|
import net.yacy.kelondro.logging.Log;
|
|
|
|
public class YMarkTables {
|
|
|
|
public static enum TABLES {
|
|
BOOKMARKS ("_bookmarks"),
|
|
TAGS ("_tags"),
|
|
FOLDERS ("_folders");
|
|
|
|
private String basename;
|
|
|
|
private TABLES(String b) {
|
|
this.basename = b;
|
|
}
|
|
public String basename() {
|
|
return this.basename;
|
|
}
|
|
public String tablename(String user) {
|
|
return user+this.basename;
|
|
}
|
|
}
|
|
|
|
public static enum PROTOCOL {
|
|
HTTP ("http://"),
|
|
HTTPS ("https://");
|
|
|
|
private String protocol;
|
|
|
|
private PROTOCOL(String s) {
|
|
this.protocol = s;
|
|
}
|
|
public String protocol() {
|
|
return this.protocol;
|
|
}
|
|
public String protocol(String s) {
|
|
return this.protocol+s;
|
|
}
|
|
}
|
|
|
|
public static enum BOOKMARK {
|
|
URL ("url", ""),
|
|
TITLE ("title", ""),
|
|
DESC ("desc", ""),
|
|
DATE_ADDED ("date_added", ""),
|
|
DATE_MODIFIED ("date_modified", ""),
|
|
DATE_VISITED ("date_visited", ""),
|
|
PUBLIC ("public", "flase"),
|
|
TAGS ("tags", "unsorted"),
|
|
VISITS ("visits", "0"),
|
|
FOLDERS ("folders", "/unsorted");
|
|
|
|
private String key;
|
|
private String dflt;
|
|
|
|
private BOOKMARK(String k, String s) {
|
|
this.key = k;
|
|
this.dflt = s;
|
|
}
|
|
public String key() {
|
|
return this.key;
|
|
}
|
|
public String deflt() {
|
|
return this.dflt;
|
|
}
|
|
public byte[] b_deflt() {
|
|
return dflt.getBytes();
|
|
}
|
|
}
|
|
|
|
public final static String TABLE_BOOKMARKS_LOG = "BOOKMARKS";
|
|
public final static String TABLE_BOOKMARKS_COL_ID = "id";
|
|
|
|
public final static String TABLE_BOOKMARKS_USER_ADMIN = "admin";
|
|
public final static String TABLE_BOOKMARKS_USER_AUTHENTICATE = "AUTHENTICATE";
|
|
public final static String TABLE_BOOKMARKS_USER_AUTHENTICATE_MSG = "Authentication required!";
|
|
|
|
public final static String TABLE_TAGS_SEPARATOR = ",";
|
|
|
|
public final static String TABLE_INDEX_COL_ID = "id";
|
|
public final static String TABLE_INDEX_COL_NAME = "name";
|
|
public final static String TABLE_INDEX_DESC = "desc";
|
|
public final static String TABLE_INDEX_COL_URLS = "urls";
|
|
public final static short TABLE_INDEX_ACTION_ADD = 1;
|
|
public final static short TABLE_INDEX_ACTION_REMOVE = 2;
|
|
|
|
public final static String TABLE_FOLDERS_SEPARATOR = "/";
|
|
public final static String TABLE_FOLDERS_ROOT = "/";
|
|
public final static String TABLE_FOLDERS_UNSORTED = "/unsorted";
|
|
public final static String TABLE_FOLDERS_IMPORTED = "/imported";
|
|
|
|
private WorkTables worktables;
|
|
public ConcurrentARC<String, byte[]> cache;
|
|
|
|
public YMarkTables(final Tables wt) {
|
|
this.worktables = (WorkTables)wt;
|
|
this.cache = new ConcurrentARC<String, byte[]>(50,1);
|
|
}
|
|
|
|
public final static byte[] getBookmarkId(String url) throws MalformedURLException {
|
|
return (new DigestURI(url, null)).hash();
|
|
}
|
|
|
|
public final static byte[] getKeyId(final String tag) {
|
|
return Word.word2hash(tag.toLowerCase());
|
|
}
|
|
|
|
public final static byte[] keySetToBytes(final HashSet<String> urlSet) {
|
|
final Iterator<String> urlIter = urlSet.iterator();
|
|
final
|
|
StringBuilder urls = new StringBuilder(urlSet.size()*20);
|
|
while(urlIter.hasNext()) {
|
|
urls.append(TABLE_TAGS_SEPARATOR);
|
|
urls.append(urlIter.next());
|
|
}
|
|
urls.deleteCharAt(0);
|
|
return urls.toString().getBytes();
|
|
}
|
|
|
|
public final static HashSet<String> keysStringToSet(final String keysString) {
|
|
HashSet<String> keySet = new HashSet<String>();
|
|
final String[] keyArray = keysString.split(TABLE_TAGS_SEPARATOR);
|
|
for (final String key : keyArray) {
|
|
keySet.add(key);
|
|
}
|
|
return keySet;
|
|
}
|
|
|
|
public final static String cleanTagsString(String tagsString) {
|
|
// get rid of heading, trailing and double commas since they are useless
|
|
while (tagsString.length() > 0 && tagsString.charAt(0) == TABLE_TAGS_SEPARATOR.charAt(0)) {
|
|
tagsString = tagsString.substring(1);
|
|
}
|
|
while (tagsString.endsWith(TABLE_TAGS_SEPARATOR)) {
|
|
tagsString = tagsString.substring(0,tagsString.length() -1);
|
|
}
|
|
while (tagsString.contains(",,")){
|
|
tagsString = tagsString.replaceAll(",,", TABLE_TAGS_SEPARATOR);
|
|
}
|
|
// space characters following a comma are removed
|
|
tagsString = tagsString.replaceAll(",\\s+", TABLE_TAGS_SEPARATOR);
|
|
return tagsString;
|
|
}
|
|
|
|
public final static String cleanFoldersString(String foldersString) {
|
|
foldersString = cleanTagsString(foldersString);
|
|
// get rid of double and trailing slashes
|
|
while (foldersString.endsWith(TABLE_FOLDERS_SEPARATOR)){
|
|
foldersString = foldersString.substring(0, foldersString.length() -1);
|
|
}
|
|
while (foldersString.contains("/,")){
|
|
foldersString = foldersString.replaceAll("/,", TABLE_TAGS_SEPARATOR);
|
|
}
|
|
while (foldersString.contains("//")){
|
|
foldersString = foldersString.replaceAll("//", TABLE_FOLDERS_SEPARATOR);
|
|
}
|
|
return foldersString;
|
|
}
|
|
|
|
public void cleanCache(final String tablename) {
|
|
final Iterator<String> iter = this.cache.keySet().iterator();
|
|
while(iter.hasNext()) {
|
|
final String key = iter.next();
|
|
if (key.startsWith(tablename)) {
|
|
this.cache.remove(key);
|
|
}
|
|
}
|
|
}
|
|
|
|
public void createIndexEntry(final String index_table, final String keyname, final HashSet<String> urlSet) throws IOException {
|
|
final byte[] key = YMarkTables.getKeyId(keyname);
|
|
final String cacheKey = index_table+":"+keyname;
|
|
final byte[] BurlSet = keySetToBytes(urlSet);
|
|
Data tagEntry = new Data();
|
|
|
|
this.cache.insert(cacheKey, BurlSet);
|
|
|
|
tagEntry.put(TABLE_INDEX_COL_NAME, keyname);
|
|
tagEntry.put(TABLE_INDEX_COL_URLS, BurlSet);
|
|
this.worktables.insert(index_table, key, tagEntry);
|
|
}
|
|
|
|
public HashSet<String> getBookmarks(final String index_table, final String keyname) throws IOException, RowSpaceExceededException {
|
|
final String cacheKey = index_table+":"+keyname;
|
|
if (this.cache.containsKey(cacheKey)) {
|
|
return keysStringToSet(new String(this.cache.get(cacheKey)));
|
|
} else {
|
|
final Tables.Row idx_row = this.worktables.select(index_table, YMarkTables.getKeyId(keyname));
|
|
if (idx_row != null) {
|
|
final byte[] keys = idx_row.get(YMarkTables.TABLE_INDEX_COL_URLS);
|
|
this.cache.put(cacheKey, keys);
|
|
return keysStringToSet(new String(keys));
|
|
}
|
|
}
|
|
return new HashSet<String>();
|
|
}
|
|
|
|
public HashSet<String> getBookmarks(final String index_table, final String[] keyArray) throws IOException, RowSpaceExceededException {
|
|
final HashSet<String> urlSet = new HashSet<String>();
|
|
urlSet.addAll(getBookmarks(index_table, keyArray[0]));
|
|
if (urlSet.isEmpty())
|
|
return urlSet;
|
|
if (keyArray.length > 1) {
|
|
for (final String keyname : keyArray) {
|
|
urlSet.retainAll(getBookmarks(index_table, keyname));
|
|
if (urlSet.isEmpty())
|
|
return urlSet;
|
|
}
|
|
}
|
|
return urlSet;
|
|
}
|
|
|
|
/**
|
|
* YMark function that updates the tag/folder index
|
|
* @param index_table is the user specific index
|
|
* @param keyname
|
|
* @param url is the url has as returned by DigestURI.hash()
|
|
* @param action is either add (1) or remove (2)
|
|
*/
|
|
public void updateIndexTable(final String index_table, final String keyname, final byte[] url, final int action) {
|
|
final byte[] key = YMarkTables.getKeyId(keyname);
|
|
final String urlHash = new String(url);
|
|
Tables.Row row = null;
|
|
|
|
// try to load urlSet from cache
|
|
final String cacheKey = index_table+":"+keyname;
|
|
HashSet<String>urlSet = this.cache.containsKey(cacheKey) ? keysStringToSet(new String(this.cache.get(cacheKey))) : new HashSet<String>();
|
|
|
|
try {
|
|
row = this.worktables.select(index_table, key);
|
|
|
|
// key has no index_table entry
|
|
if(row == null) {
|
|
switch (action) {
|
|
case TABLE_INDEX_ACTION_ADD:
|
|
urlSet.add(urlHash);
|
|
createIndexEntry(index_table, keyname, urlSet);
|
|
break;
|
|
case TABLE_INDEX_ACTION_REMOVE:
|
|
// key has no index_table entry but a cache entry
|
|
// TODO: this shouldn't happen
|
|
if(!urlSet.isEmpty()) {
|
|
urlSet.remove(urlHash);
|
|
createIndexEntry(index_table, keyname, urlSet);
|
|
}
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
// key has an existing index_table entry
|
|
else {
|
|
byte[] BurlSet = null;
|
|
// key has no cache entry
|
|
if (urlSet.isEmpty()) {
|
|
// load urlSet from index_table
|
|
urlSet = keysStringToSet(new String(row.get(TABLE_INDEX_COL_URLS)));
|
|
}
|
|
switch (action) {
|
|
case TABLE_INDEX_ACTION_ADD:
|
|
urlSet.add(urlHash);
|
|
break;
|
|
case TABLE_INDEX_ACTION_REMOVE:
|
|
urlSet.remove(urlHash);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
if (urlSet.isEmpty()) {
|
|
this.cache.remove(cacheKey);
|
|
this.worktables.delete(index_table, key);
|
|
} else {
|
|
BurlSet = keySetToBytes(urlSet);
|
|
this.cache.insert(cacheKey, BurlSet);
|
|
row.put(TABLE_INDEX_COL_URLS, BurlSet);
|
|
this.worktables.update(index_table, row);
|
|
}
|
|
}
|
|
} catch (IOException e) {
|
|
Log.logException(e);
|
|
} catch (RowSpaceExceededException e) {
|
|
Log.logException(e);
|
|
}
|
|
}
|
|
}
|