use of com.biglybt.pif.download.Download in project BiglyBT by BiglySoftware.
the class LocalTrackerPlugin method track.
protected void track() {
long now = plugin_interface.getUtilities().getCurrentSystemTime();
if (now - plugin_start_time < 60 * 1000) {
try {
// initial small delay to let things stabilise
Thread.sleep(15 * 1000);
} catch (Throwable e) {
}
}
plugin_interface.getUtilities().createTimer("LanPeerFinder:Tracker", false).addPeriodicEvent(30 * 1000, new UTTimerEventPerformer() {
@Override
public void perform(UTTimerEvent event) {
current_time = plugin_interface.getUtilities().getCurrentSystemTime();
try {
List<Download> todo = new ArrayList<>();
try {
mon.enter();
Iterator<Map.Entry<Download, long[]>> it = downloads.entrySet().iterator();
while (it.hasNext()) {
Map.Entry<Download, long[]> entry = it.next();
Download dl = entry.getKey();
long when = entry.getValue()[0];
if (when > current_time || current_time - when > ANNOUNCE_PERIOD) {
todo.add(dl);
}
}
} finally {
mon.exit();
}
for (int i = 0; i < todo.size(); i++) {
track(todo.get(i));
}
} catch (Throwable e) {
log.log(e);
}
}
});
}
use of com.biglybt.pif.download.Download in project BiglyBT by BiglySoftware.
the class RelatedContentManager method publish.
private boolean publish(final DownloadInfo from_info, final DownloadInfo to_info) throws Exception {
final DHTPluginInterface dht_plugin = selectDHT(from_info.getNetworksInternal());
if (dht_plugin == null) {
return (false);
}
final String from_hash = ByteFormatter.encodeString(from_info.getHash());
final String to_hash = ByteFormatter.encodeString(to_info.getHash());
final byte[] key_bytes = ("az:rcm:assoc:" + from_hash).getBytes("UTF-8");
String title = to_info.getTitle();
if (title.length() > MAX_TITLE_LENGTH) {
title = title.substring(0, MAX_TITLE_LENGTH);
}
Map<String, Object> map = new HashMap<>();
map.put("d", title);
map.put("r", new Long(Math.abs(to_info.getRand() % 1000)));
String tracker = to_info.getTracker();
if (tracker == null) {
map.put("h", to_info.getHash());
} else {
map.put("t", tracker);
}
if (to_info.getLevel() == 0) {
try {
Download to_download = to_info.getRelatedToDownload();
if (to_download != null) {
int version = RelatedContent.VERSION_INITIAL;
Torrent torrent = to_download.getTorrent();
if (torrent != null) {
long secs = torrent.getCreationDate();
long hours = secs / (60 * 60);
if (hours > 0) {
map.put("p", new Long(hours));
}
}
DownloadManagerState state = PluginCoreUtils.unwrap(to_download).getDownloadState();
int leechers = -1;
int seeds = -1;
int[] aggregate_seeds_leechers = DownloadManagerStateFactory.getCachedAggregateScrapeSeedsLeechers(state);
if (aggregate_seeds_leechers == null) {
long cache = state.getLongAttribute(DownloadManagerState.AT_SCRAPE_CACHE);
if (cache != -1) {
seeds = (int) ((cache >> 32) & 0x00ffffff);
leechers = (int) (cache & 0x00ffffff);
}
} else {
seeds = aggregate_seeds_leechers[0];
leechers = aggregate_seeds_leechers[1];
version = RelatedContent.VERSION_BETTER_SCRAPE;
}
if (version > 0) {
map.put("v", new Long(version));
}
if (leechers > 0) {
map.put("l", new Long(leechers));
}
if (seeds > 0) {
map.put("z", new Long(seeds));
}
byte[][] keys = getKeys(to_download);
if (keys[0] != null) {
map.put("k", keys[0]);
}
if (keys[1] != null) {
map.put("w", keys[1]);
}
String[] _tags = getTags(to_download);
if (_tags != null) {
map.put("g", encodeTags(_tags));
}
byte nets = getNetworks(to_download);
if (nets != NET_PUBLIC) {
map.put("o", new Long(nets & 0xff));
}
}
} catch (Throwable e) {
Debug.out(e);
}
}
Download from_download = from_info.getRelatedToDownload();
final Set<String> my_tags = new HashSet<>();
try {
if (from_download != null) {
String[] _tags = getTags(from_download);
if (_tags != null) {
map.put("b", from_info.getRand() % 100);
map.put("m", encodeTags(_tags));
Collections.addAll(my_tags, _tags);
}
}
} catch (Throwable e) {
Debug.out(e);
}
Set<String> my_tags_original = new HashSet<>(my_tags);
long size = to_info.getSize();
if (size != 0) {
map.put("s", new Long(size));
}
final byte[] map_bytes = BEncoder.encode(map);
// System.out.println( "rcmsize=" + map_bytes.length );
final int max_hits = 30;
dht_plugin.get(key_bytes, "Content rel test: " + from_hash.substring(0, 16), DHTPlugin.FLAG_SINGLE_VALUE, max_hits, 30 * 1000, false, false, new DHTPluginOperationListener() {
private boolean diversified;
private int hits;
private Set<String> entries = new HashSet<>();
private Set<String> discovered_tags = new HashSet<>();
@Override
public void starts(byte[] key) {
}
@Override
public boolean diversified() {
diversified = true;
return (false);
}
@Override
public void valueRead(DHTPluginContact originator, DHTPluginValue value) {
try {
Map<String, Object> map = (Map<String, Object>) BDecoder.decode(value.getValue());
DownloadInfo info = decodeInfo(map, from_info.getHash(), 1, false, entries);
try {
String[] r_tags = decodeTags((byte[]) map.get("m"));
if (r_tags != null) {
Long b = (Long) map.get("b");
if (b == null || from_info.getRand() % 100 != b % 100) {
for (String tag : r_tags) {
synchronized (my_tags) {
my_tags.remove(tag);
if (!my_tags_original.contains(tag)) {
discovered_tags.add(tag);
}
}
}
}
}
} catch (Throwable e) {
}
if (info != null) {
analyseResponse(info, null);
}
} catch (Throwable e) {
}
hits++;
}
@Override
public void valueWritten(DHTPluginContact target, DHTPluginValue value) {
}
@Override
public void complete(byte[] key, boolean timeout_occurred) {
if (from_download != null) {
synchronized (my_tags) {
if (!discovered_tags.isEmpty()) {
Set<String> interesting = new HashSet<>();
for (String tag : discovered_tags) {
if (TagUtils.isInternalTagName(tag)) {
continue;
}
interesting.add(tag);
}
if (!interesting.isEmpty()) {
try {
DownloadManagerState dms = PluginCoreUtils.unwrap(from_download).getDownloadState();
String[] old = dms.getListAttribute(DownloadManagerState.AT_SWARM_TAGS);
if (old == null || old.length == 0) {
dms.setListAttribute(DownloadManagerState.AT_SWARM_TAGS, interesting.toArray(new String[0]));
} else {
if (old.length < 16) {
interesting.addAll(Arrays.asList(old));
if (interesting.size() > old.length) {
dms.setListAttribute(DownloadManagerState.AT_SWARM_TAGS, interesting.toArray(new String[0]));
}
}
}
} catch (Throwable e) {
}
}
}
}
}
// if we have something to say prioritise it somewhat
int f_cutoff = my_tags.size() > 0 ? 20 : 10;
try {
boolean do_it;
if (diversified || hits >= f_cutoff) {
do_it = false;
} else if (hits <= f_cutoff / 2) {
do_it = true;
} else {
do_it = RandomUtils.nextInt(hits - (f_cutoff / 2) + 1) == 0;
}
if (do_it) {
try {
dht_plugin.put(key_bytes, "Content rel: " + from_hash.substring(0, 16) + " -> " + to_hash.substring(0, 16), map_bytes, DHTPlugin.FLAG_ANON, new DHTPluginOperationListener() {
@Override
public boolean diversified() {
return (true);
}
@Override
public void starts(byte[] key) {
}
@Override
public void valueRead(DHTPluginContact originator, DHTPluginValue value) {
}
@Override
public void valueWritten(DHTPluginContact target, DHTPluginValue value) {
}
@Override
public void complete(byte[] key, boolean timeout_occurred) {
publishNext();
}
});
} catch (Throwable e) {
Debug.printStackTrace(e);
publishNext();
}
} else {
publishNext();
}
} finally {
checkAlternativePubs(to_info, map_bytes, f_cutoff);
}
}
});
return (true);
}
use of com.biglybt.pif.download.Download in project BiglyBT by BiglySoftware.
the class MagnetPlugin method initialize.
@Override
public void initialize(PluginInterface _plugin_interface) {
plugin_interface = _plugin_interface;
MagnetURIHandler uri_handler = MagnetURIHandler.getSingleton();
final LocaleUtilities lu = plugin_interface.getUtilities().getLocaleUtilities();
lu.addListener(new LocaleListener() {
@Override
public void localeChanged(Locale l) {
updateLocale(lu);
}
});
updateLocale(lu);
BasicPluginConfigModel config = plugin_interface.getUIManager().createBasicPluginConfigModel(ConfigSection.SECTION_PLUGINS, PLUGIN_CONFIGSECTION_ID);
config.addInfoParameter2("MagnetPlugin.current.port", String.valueOf(uri_handler.getPort()));
md_lookup = config.addBooleanParameter2("MagnetPlugin.use.md.download", "MagnetPlugin.use.md.download", true);
md_lookup_delay = config.addIntParameter2("MagnetPlugin.use.md.download.delay", "MagnetPlugin.use.md.download.delay", MD_LOOKUP_DELAY_SECS_DEFAULT);
String et_default = "";
for (String etd : MD_EXTRA_TRACKERS) {
et_default += (et_default.isEmpty() ? "" : "\n") + etd;
}
md_extra_trackers = config.addStringParameter2("MagnetPlugin.md.extra.trackers", "MagnetPlugin.md.extra.trackers", et_default);
md_extra_trackers.setMultiLine(3);
md_lookup.addEnabledOnSelection(md_lookup_delay);
md_lookup.addEnabledOnSelection(md_extra_trackers);
timeout_param = config.addIntParameter2("MagnetPlugin.timeout.secs", "MagnetPlugin.timeout.secs", PLUGIN_DOWNLOAD_TIMEOUT_SECS_DEFAULT);
sources_param = config.addStringListParameter2("MagnetPlugin.add.sources", "MagnetPlugin.add.sources", SOURCE_VALUES, SOURCE_STRINGS, SOURCE_VALUES[1]);
sources_extra_param = config.addIntParameter2("MagnetPlugin.add.sources.extra", "MagnetPlugin.add.sources.extra", 0);
magnet_recovery = config.addBooleanParameter2("MagnetPlugin.recover.magnets", "MagnetPlugin.recover.magnets", true);
magnet_recovery_concurrency = config.addIntParameter2("MagnetPlugin.recover.magnets.conc", "MagnetPlugin.recover.magnets.conc", 32, 8, 512);
magnet_recovery_concurrency.setIndent(1, true);
magnet_recovery.addEnabledOnSelection(magnet_recovery_concurrency);
BooleanParameter rename = config.addBooleanParameter2("MagnetPlugin.rename.using.dn", "MagnetPlugin.rename.using.dn", false);
BooleanParameter rename_ext = config.addBooleanParameter2("MagnetPlugin.rename.using.dn.only.with.ext", "MagnetPlugin.rename.using.dn.only.with.ext", false);
rename_ext.setIndent(1, true);
rename.addEnabledOnSelection(rename_ext);
Parameter[] nps = new Parameter[AENetworkClassifier.AT_NETWORKS.length];
for (int i = 0; i < nps.length; i++) {
String nn = AENetworkClassifier.AT_NETWORKS[i];
String config_name = "Network Selection Default." + nn;
String msg_text = "ConfigView.section.connection.networks." + nn;
final BooleanParameter param = config.addBooleanParameter2(config_name, msg_text, COConfigurationManager.getBooleanParameter(config_name));
COConfigurationManager.addParameterListener(config_name, new com.biglybt.core.config.ParameterListener() {
@Override
public void parameterChanged(String name) {
param.setDefaultValue(COConfigurationManager.getBooleanParameter(name));
}
});
nps[i] = param;
net_params.put(nn, param);
}
config.createGroup("label.default.nets", nps);
MenuItemListener listener = new MenuItemListener() {
@Override
public void selected(MenuItem _menu, Object _target) {
TableRow[] rows = (TableRow[]) _target;
String cb_all_data = "";
for (TableRow row : rows) {
Torrent torrent;
String name;
Object ds = row.getDataSource();
Download download = null;
ShareResource share = null;
if (ds instanceof ShareResourceFile) {
ShareResourceFile sf = (ShareResourceFile) ds;
try {
torrent = sf.getItem().getTorrent();
} catch (ShareException e) {
continue;
}
name = sf.getName();
share = sf;
} else if (ds instanceof ShareResourceDir) {
ShareResourceDir sd = (ShareResourceDir) ds;
try {
torrent = sd.getItem().getTorrent();
} catch (ShareException e) {
continue;
}
name = sd.getName();
share = sd;
} else if (ds instanceof Download) {
download = (Download) ds;
torrent = download.getTorrent();
name = download.getName();
} else {
continue;
}
boolean is_share = false;
Set<String> networks = new HashSet<>();
if (share != null) {
is_share = true;
Map<String, String> properties = share.getProperties();
if (properties != null) {
String nets = properties.get(ShareManager.PR_NETWORKS);
if (nets != null) {
String[] bits = nets.split(",");
for (String bit : bits) {
bit = AENetworkClassifier.internalise(bit.trim());
if (bit != null) {
networks.add(bit);
}
}
}
}
}
if (download != null) {
TorrentAttribute ta = plugin_interface.getTorrentManager().getAttribute(TorrentAttribute.TA_NETWORKS);
String[] nets = download.getListAttribute(ta);
networks.addAll(Arrays.asList(nets));
try {
byte[] hash = download.getTorrentHash();
if (plugin_interface.getShareManager().lookupShare(hash) != null) {
is_share = true;
}
} catch (Throwable e) {
}
}
String cb_data = download == null ? UrlUtils.getMagnetURI(name, torrent) : UrlUtils.getMagnetURI(download);
if (download != null) {
List<Tag> tags = TagManagerFactory.getTagManager().getTagsForTaggable(TagType.TT_DOWNLOAD_MANUAL, PluginCoreUtils.unwrap(download));
for (Tag tag : tags) {
if (tag.isPublic()) {
if (!tag.isTagAuto()[0]) {
cb_data += "&tag=" + UrlUtils.encode(tag.getTagName(true));
}
}
}
}
String sources = sources_param.getValue();
boolean add_sources = sources.equals("2") || (sources.equals("1") && is_share);
if (add_sources) {
if (networks.isEmpty()) {
for (String net : AENetworkClassifier.AT_NETWORKS) {
if (isNetworkEnabled(net)) {
networks.add(net);
}
}
}
if (networks.contains(AENetworkClassifier.AT_PUBLIC) && !cb_data.contains("xsource=")) {
DownloadManager dm = download == null ? null : PluginCoreUtils.unwrap(download);
InetAddress ip = NetworkAdmin.getSingleton().getDefaultPublicAddress();
InetAddress ip_v6 = NetworkAdmin.getSingleton().getDefaultPublicAddressV6();
int port = dm == null ? TCPNetworkManager.getSingleton().getDefaultTCPListeningPortNumber() : dm.getTCPListeningPortNumber();
if (ip != null && port > 0) {
cb_data += "&xsource=" + UrlUtils.encode(UrlUtils.getURLForm(ip, port));
}
if (ip_v6 != null && port > 0) {
cb_data += "&xsource=" + UrlUtils.encode(UrlUtils.getURLForm(ip_v6, port));
}
int extra = sources_extra_param.getValue();
if (extra > 0) {
if (download == null) {
if (torrent != null) {
download = plugin_interface.getDownloadManager().getDownload(torrent);
}
}
if (download != null) {
Set<String> added = new HashSet<>();
PEPeerManager pm = dm.getPeerManager();
if (pm != null) {
List<PEPeer> peers = pm.getPeers();
for (PEPeer peer : peers) {
String peer_ip = peer.getIp();
if (AENetworkClassifier.categoriseAddress(peer_ip) == AENetworkClassifier.AT_PUBLIC) {
int peer_port = peer.getTCPListenPort();
if (peer_port > 0) {
cb_data += "&xsource=" + UrlUtils.encode(UrlUtils.getURLForm(peer_ip, peer_port));
added.add(peer_ip);
extra--;
if (extra == 0) {
break;
}
}
}
}
}
if (extra > 0) {
Map response_cache = dm.getDownloadState().getTrackerResponseCache();
if (response_cache != null) {
List<TRTrackerAnnouncerResponsePeer> peers = TRTrackerAnnouncerFactory.getCachedPeers(response_cache);
for (TRTrackerAnnouncerResponsePeer peer : peers) {
String peer_ip = peer.getAddress();
if (AENetworkClassifier.categoriseAddress(peer_ip) == AENetworkClassifier.AT_PUBLIC) {
if (!added.contains(peer_ip)) {
int peer_port = peer.getPort();
if (peer_port > 0) {
cb_data += "&xsource=" + UrlUtils.encode(UrlUtils.getURLForm(peer_ip, peer_port));
added.add(peer_ip);
extra--;
if (extra == 0) {
break;
}
}
}
}
}
}
}
}
}
}
}
// removed this as well - nothing wrong with allowing magnet copy
// for private torrents - they still can't be tracked if you don't
// have permission
/*if ( torrent.isPrivate()){
cb_data = getMessageText( "private_torrent" );
}else if ( torrent.isDecentralised()){
*/
// ok
/* relaxed this as we allow such torrents to be downloaded via magnet links
* (as opposed to tracked in the DHT)
}else if ( torrent.isDecentralisedBackupEnabled()){
TorrentAttribute ta_peer_sources = plugin_interface.getTorrentManager().getAttribute( TorrentAttribute.TA_PEER_SOURCES );
String[] sources = download.getListAttribute( ta_peer_sources );
boolean ok = false;
for (int i=0;i<sources.length;i++){
if ( sources[i].equalsIgnoreCase( "DHT")){
ok = true;
break;
}
}
if ( !ok ){
cb_data = getMessageText( "decentral_disabled" );
}
}else{
cb_data = getMessageText( "decentral_backup_disabled" );
*/
// }
// System.out.println( "MagnetPlugin: export = " + url );
cb_all_data += (cb_all_data.length() == 0 ? "" : "\n") + cb_data;
}
try {
plugin_interface.getUIManager().copyToClipBoard(cb_all_data);
} catch (Throwable e) {
e.printStackTrace();
}
}
};
List<TableContextMenuItem> menus = new ArrayList<>();
for (String table : TableManager.TABLE_MYTORRENTS_ALL) {
TableContextMenuItem menu = plugin_interface.getUIManager().getTableManager().addContextMenuItem(table, "MagnetPlugin.contextmenu.exporturi");
menu.addMultiListener(listener);
menu.setHeaderCategory(MenuItem.HEADER_SOCIAL);
menus.add(menu);
}
uri_handler.addListener(new MagnetURIHandlerListener() {
@Override
public byte[] badge() {
InputStream is = getClass().getClassLoader().getResourceAsStream("com/biglybt/plugin/magnet/Magnet.gif");
if (is == null) {
return (null);
}
try {
ByteArrayOutputStream baos = new ByteArrayOutputStream();
try {
byte[] buffer = new byte[8192];
while (true) {
int len = is.read(buffer);
if (len <= 0) {
break;
}
baos.write(buffer, 0, len);
}
} finally {
is.close();
}
return (baos.toByteArray());
} catch (Throwable e) {
Debug.printStackTrace(e);
return (null);
}
}
@Override
public byte[] download(MagnetURIHandlerProgressListener muh_listener, byte[] hash, String args, InetSocketAddress[] sources, long timeout) throws MagnetURIHandlerException {
try {
Download dl = plugin_interface.getDownloadManager().getDownload(hash);
if (dl != null) {
// might just be an existing metadata download
com.biglybt.core.download.DownloadManager core_dm = PluginCoreUtils.unwrap(dl);
if (!core_dm.getDownloadState().getFlag(DownloadManagerState.FLAG_METADATA_DOWNLOAD)) {
Torrent torrent = dl.getTorrent();
if (torrent != null) {
byte[] torrent_data = torrent.writeToBEncodedData();
torrent_data = addTrackersAndWebSeedsEtc(torrent_data, args, new HashSet<String>(), Collections.emptyList(), Collections.emptyMap());
return (torrent_data);
}
}
}
} catch (Throwable e) {
Debug.printStackTrace(e);
}
Object[] result = { null };
AESemaphore sem = new AESemaphore("dlwait");
DownloadAsyncListener dl_listener = new DownloadAsyncListener() {
@Override
public void failed(MagnetURIHandlerException error) {
synchronized (result) {
result[0] = error;
}
sem.release();
}
@Override
public void complete(byte[] torrent_data) {
synchronized (result) {
result[0] = torrent_data;
}
sem.release();
}
};
recoverableDownload(muh_listener, hash, args, sources, Collections.emptyList(), Collections.emptyMap(), timeout, SystemTime.getCurrentTime(), false, dl_listener);
sem.reserve();
synchronized (result) {
Object r = result[0];
if (r instanceof MagnetURIHandlerException) {
throw ((MagnetURIHandlerException) r);
} else {
return ((byte[]) r);
}
}
}
@Override
public boolean download(URL url) throws MagnetURIHandlerException {
try {
plugin_interface.getDownloadManager().addDownload(url, false);
return (true);
} catch (DownloadException e) {
throw (new MagnetURIHandlerException("Operation failed", e));
}
}
@Override
public boolean set(String name, Map values) {
List l = listeners.getList();
for (int i = 0; i < l.size(); i++) {
if (((MagnetPluginListener) l.get(i)).set(name, values)) {
return (true);
}
}
return (false);
}
@Override
public int get(String name, Map values) {
List l = listeners.getList();
for (int i = 0; i < l.size(); i++) {
int res = ((MagnetPluginListener) l.get(i)).get(name, values);
if (res != Integer.MIN_VALUE) {
return (res);
}
}
return (Integer.MIN_VALUE);
}
});
plugin_interface.getUIManager().addUIListener(new UIManagerListener() {
@Override
public void UIAttached(UIInstance instance) {
if (instance.getUIType().equals(UIInstance.UIT_SWT)) {
try {
Class.forName("com.biglybt.plugin.magnet.swt.MagnetPluginUISWT").getConstructor(new Class[] { UIInstance.class, TableContextMenuItem[].class }).newInstance(new Object[] { instance, menus.toArray(new TableContextMenuItem[menus.size()]) });
} catch (Throwable e) {
e.printStackTrace();
}
}
}
@Override
public void UIDetached(UIInstance instance) {
}
});
final List<Download> to_delete = new ArrayList<>();
Download[] downloads = plugin_interface.getDownloadManager().getDownloads();
for (Download download : downloads) {
if (download.getFlag(Download.FLAG_METADATA_DOWNLOAD)) {
to_delete.add(download);
}
}
final AESemaphore delete_done = new AESemaphore("delete waiter");
if (to_delete.size() > 0) {
AEThread2 t = new AEThread2("MagnetPlugin:delmds", true) {
@Override
public void run() {
try {
for (Download download : to_delete) {
try {
download.stopAndRemove(true, true);
} catch (Throwable e) {
Debug.out(e);
}
}
} finally {
delete_done.release();
}
}
};
t.start();
} else {
delete_done.release();
}
plugin_interface.addListener(new PluginListener() {
@Override
public void initializationComplete() {
// make sure DDB is initialised as we need it to register its
// transfer types
AEThread2 t = new AEThread2("MagnetPlugin:init", true) {
@Override
public void run() {
delete_done.reserve();
recoverDownloads();
try {
DistributedDatabase db = plugin_interface.getDistributedDatabase();
synchronized (db_holder) {
db_holder[0] = db;
}
} catch (Throwable e) {
Debug.out(e);
} finally {
db_waiter.releaseForever();
}
}
};
t.start();
}
@Override
public void closedownInitiated() {
updateRecoverableDownloads();
}
@Override
public void closedownComplete() {
}
});
}
use of com.biglybt.pif.download.Download in project BiglyBT by BiglySoftware.
the class MagnetPlugin method updateRecoverableDownloads.
private void updateRecoverableDownloads() {
boolean recover = magnet_recovery.getValue();
if (recover) {
synchronized (download_activities) {
Map<String, Map> active = COConfigurationManager.getMapParameter("MagnetPlugin.active.magnets", new HashMap());
if (active.size() > 0) {
active = BEncoder.cloneMap(active);
boolean do_update = false;
for (Map map : active.values()) {
try {
byte[] hash = (byte[]) map.get("hash");
Download download = plugin_interface.getDownloadManager().getDownload(hash);
if (download != null) {
com.biglybt.core.download.DownloadManager core_dm = PluginCoreUtils.unwrap(download);
if (updateInitialMetadata(map, core_dm)) {
do_update = true;
}
}
} catch (Throwable e) {
}
}
if (do_update) {
COConfigurationManager.setParameter("MagnetPlugin.active.magnets", active);
}
}
}
}
}
use of com.biglybt.pif.download.Download in project BiglyBT by BiglySoftware.
the class BuddyPluginBeta method startup.
protected void startup() {
plugin_interface.addEventListener(new PluginEventListener() {
@Override
public void handleEvent(PluginEvent ev) {
int type = ev.getType();
if (type == PluginEvent.PEV_PLUGIN_OPERATIONAL) {
pluginAdded((PluginInterface) ev.getValue());
} else if (type == PluginEvent.PEV_PLUGIN_NOT_OPERATIONAL) {
pluginRemoved((PluginInterface) ev.getValue());
}
}
});
PluginInterface[] plugins = plugin_interface.getPluginManager().getPlugins(true);
for (PluginInterface pi : plugins) {
if (pi.getPluginState().isOperational()) {
pluginAdded(pi);
}
}
boolean check_all = COConfigurationManager.getBooleanParameter("azbuddy.dchat.autotracker.scan", true);
COConfigurationManager.setParameter("azbuddy.dchat.autotracker.scan", false);
plugin_interface.getDownloadManager().addListener(new DownloadManagerListener() {
private Set<String> checked = new HashSet<>();
@Override
public void downloadAdded(Download download) {
if (COConfigurationManager.getBooleanParameter(ConfigKeys.Tag.BCFG_TRACKER_AUTO_TAG_INTERESTING_TRACKERS)) {
Torrent torrent = download.getTorrent();
if (torrent != null) {
TOTorrent to_torrent = PluginCoreUtils.unwrap(download.getTorrent());
if (TorrentUtils.isReallyPrivate(to_torrent)) {
Set<String> hosts = TorrentUtils.getUniqueTrackerHosts(to_torrent);
if (hosts.size() == 1) {
String tracker = DNSUtils.getInterestingHostSuffix(hosts.iterator().next());
if (tracker != null && !checked.contains(tracker)) {
checked.add(tracker);
try {
String config_key = "azbuddy.dchat.autotracker.host." + Base32.encode(tracker.getBytes("UTF-8"));
boolean done = COConfigurationManager.getBooleanParameter(config_key, false);
if (!done) {
COConfigurationManager.setParameter(config_key, true);
String chat_key = "Tracker: " + tracker;
ChatInstance chat = getChat(AENetworkClassifier.AT_PUBLIC, chat_key);
chat.setFavourite(true);
BuddyPluginUI.openChat(chat);
TagManager tm = TagManagerFactory.getTagManager();
if (tm.isEnabled()) {
TagType tt = tm.getTagType(TagType.TT_DOWNLOAD_MANUAL);
Tag tag = tt.getTag(tracker, true);
if (tag == null) {
tag = tt.createTag(tracker, false);
tag.setPublic(false);
tt.addTag(tag);
TagFeatureProperties tfp = (TagFeatureProperties) tag;
TagProperty tp = tfp.getProperty(TagFeatureProperties.PR_TRACKERS);
tp.setStringList(new String[] { tracker });
}
}
}
} catch (Throwable e) {
}
}
}
}
}
}
}
@Override
public void downloadRemoved(Download download) {
}
}, check_all);
}
Aggregations