mirroring bot - 2024/10/24

Author: updating-bot

svn_trunk/src/jd/controlling/AccountController.java

@@ -6,7 +6,6 @@
 import java.util.List;
 import java.util.concurrent.atomic.AtomicReference;
 
-import org.appwork.utils.DebugMode;
 import org.appwork.utils.StringUtils;
 import org.jdownloader.DomainInfo;
 import org.jdownloader.controlling.hosterrule.AccountGroup.Rules;
@@ -16,8 +15,6 @@
 import jd.plugins.Account;
 import jd.plugins.AccountInfo;
 import jd.plugins.DownloadLink;
-import jd.plugins.MultiHostHost;
-import jd.plugins.MultiHostHost.MultihosterHostStatus;
 import jd.plugins.PluginForHost;
 
 public class AccountCache implements Iterable<CachedAccount> {
@@ -98,51 +95,6 @@ public boolean canHandle(DownloadLink link) throws Exception {
                     /* Host is not supported (anymore) */
                     return false;
                 }
-                /* Verify again because plugins can modify list on runtime */
-                if (DebugMode.TRUE_IN_IDE_ELSE_FALSE) {
-                    /* Check for domain specific limits of multihost items. */
-                    final MultiHostHost hostinfo = ai.getMultihostSupportedHost(link.getHost());
-                    if (hostinfo == null) {
-                        /* Host is not supported (anymore) */
-                        return false;
-                    }
-                    final MultihosterHostStatus status = hostinfo.getStatus();
-                    if (status != MultihosterHostStatus.WORKING && status != MultihosterHostStatus.WORKING_UNSTABLE) {
-                        /* Download of that host is currently not possible. */
-                        return false;
-                    } else if (!hostinfo.isUnlimitedLinks() && hostinfo.getLinksLeft() <= 0) {
-                        /* Max limits link is reached -> Cannot download */
-                        return false;
-                    }
-                    // TODO: Refactor this
-                    if (!hostinfo.isUnlimitedTraffic()) {
-                        /* Traffic limit exists -> Check if enough traffic is left. */
-                        if (hostinfo.getTrafficLeft() <= 0) {
-                            /* No traffic left at all. */
-                            return false;
-                        }
-                        if (link.isSizeSet()) {
-                            /* File size is known so we can check if we have enough traffic left to download that link. */
-                            final long trafficCalcFactor = hostinfo.getTrafficCalculationFactorPercent();
-                            final long downloadSize = link.getView().getBytesTotalEstimated();
-                            final long minimum = 1024;
-                            final long downloadLeft;
-                            if (downloadSize >= 0) {
-                                downloadLeft = Math.max(minimum, downloadSize - link.getView().getBytesLoaded());
-                            } else {
-                                downloadLeft = minimum;
-                            }
-                            final long neededTraffic = (downloadLeft * trafficCalcFactor) / 100;
-                            if (!ai.isUnlimitedTraffic() && neededTraffic > ai.getTrafficLeft()) {
-                                /* Not enough account traffic */
-                                return false;
-                            } else if (neededTraffic > hostinfo.getTrafficLeft()) {
-                                /* Not enough individual file host traffic */
-                                return false;
-                            }
-                        }
-                    }
-                }
             }
             return true;
         }

svn_trunk/src/jd/controlling/downloadcontroller/AccountCache.java

@@ -24,12 +24,6 @@
 import java.util.concurrent.CopyOnWriteArrayList;
 import java.util.concurrent.atomic.AtomicBoolean;
 
-import jd.config.Property;
-import jd.controlling.AccountController;
-import jd.http.Browser;
-import jd.http.Cookie;
-import jd.http.Cookies;
-
 import org.appwork.storage.JSonStorage;
 import org.appwork.storage.SimpleMapper;
 import org.appwork.storage.TypeRef;
@@ -43,6 +37,12 @@
 import org.jdownloader.settings.staticreferences.CFG_GENERAL;
 import org.jdownloader.translate._JDT;
 
+import jd.config.Property;
+import jd.controlling.AccountController;
+import jd.http.Browser;
+import jd.http.Cookie;
+import jd.http.Cookies;
+
 public class Account extends Property {
     private static final String VALID_UNTIL              = "VALID_UNTIL";
     private static final String ACCOUNT_TYPE             = "ACCOUNT_TYPE";
@@ -220,12 +220,10 @@ public Cookies loadUserCookies(final boolean loadUserAgent) {
     }
 
     /**
-     * @since JD2
-     *
-     *        true = Multiple accounts of this host can be used at the same time <br/>
-     *        false = Multiple accounts of this host can NOT be used at the same time. <br/>
-     *        For most hosts, this should be set to false for free accounts as the traffic limit of those sits on current IP + account which
-     *        means that if a traffic-limit of one free account is reached, all accounts will be out of traffic!
+     * true = Multiple accounts of this host can be used at the same time <br/>
+     * false = Multiple accounts of this host can NOT be used at the same time. <br/>
+     * For most hosts, this should be set to false for free accounts as the traffic limit of those sits on current IP + account which means
+     * that if a traffic-limit of one free account is reached, all accounts will be out of traffic!
      */
     public void setConcurrentUsePossible(boolean concurrentUsePossible) {
         this.concurrentUsePossible = concurrentUsePossible;
@@ -268,7 +266,7 @@ public PluginForHost getPlugin() {
         return plugin;
     }
 
-    public void setPlugin(PluginForHost plugin) {
+    public void setPlugin(final PluginForHost plugin) {
         this.plugin = plugin;
         if (plugin != null) {
             isMultiPlugin = plugin.isHandlingMultipleHosts();
@@ -282,9 +280,9 @@ public boolean isMultiPlugin() {
     }
 
     /**
-     * Set this to true to indicate that changing the IP address will also reset this accounts' limits. </br> Most of all services will
-     * store the limits on account (+ IP) but some will only rely on the IP thus allowing users to reset account limits by changing their
-     * IP.
+     * Set this to true to indicate that changing the IP address will also reset this accounts' limits. </br>
+     * Most of all services will store the limits on account (+ IP) but some will only rely on the IP thus allowing users to reset account
+     * limits by changing their IP.
      */
     public void setAllowReconnectToResetLimits(final boolean b) {
         /* 2022-07-19: TODO: Dummy function, see: https://svn.jdownloader.org/issues/87351 */
@@ -658,17 +656,31 @@ public void setEnabled(final boolean enabled, final boolean forceAccountCheckOnC
         }
     }
 
+    private static final long DEFAULT_REFRESH_TIMEOUT = 30 * 60 * 1000l;
+    private static final long MIN_REFRESH_TIMEOUT     = 5 * 60 * 1000l;
+
     /** In which interval (milliseconds) will this account get checked? Min. = 5 minutes, default = 30 minutes. */
     public long getRefreshTimeout() {
-        /* default refresh timeout is 30 mins */
-        long defaultRefreshTimeout = 30 * 60 * 1000l;
-        /* TODO: Also maybe check if e.g. timeout > time until account expires. */
-        final long minRefreshTimeout = 5 * 60 * 1000l;
-        Long timeout = this.getLongProperty(PROPERTY_REFRESH_TIMEOUT, defaultRefreshTimeout);
+        Long timeout = this.getLongProperty(PROPERTY_REFRESH_TIMEOUT, DEFAULT_REFRESH_TIMEOUT);
         if (timeout == null || timeout <= 0) {
-            timeout = defaultRefreshTimeout;
-        } else if (timeout < minRefreshTimeout) {
-            timeout = minRefreshTimeout;
+            timeout = DEFAULT_REFRESH_TIMEOUT;
+        } else if (timeout < MIN_REFRESH_TIMEOUT) {
+            timeout = MIN_REFRESH_TIMEOUT;
+        }
+        final AccountInfo ai = this.getAccountInfo();
+        if (ai != null) {
+            /*
+             * Check if account is is about to expire. If that happens earlier than our next planned check, return time until account
+             * expires.
+             */
+            final long validUntil = ai.getValidUntil();
+            if (validUntil == -1) {
+                return timeout;
+            }
+            final long timeValid = validUntil - System.currentTimeMillis();
+            if (timeValid > 0 && timeValid < timeout) {
+                return timeValid;
+            }
         }
         return timeout;
     }
@@ -680,6 +692,7 @@ public void setRefreshTimeout(long refresh_timeout) {
 
     public boolean refreshTimeoutReached() {
         if (updatetime <= 0) {
+            /* Account has never been checked so far. */
             return true;
         }
         return System.currentTimeMillis() - updatetime >= getRefreshTimeout();

svn_trunk/src/jd/plugins/Account.java

@@ -68,6 +68,11 @@ public boolean isTrafficRefill() {
         return account_trafficRefill;
     }
 
+    /**
+     * Set this to true if we expect this account to automatically get fresh traffic every X time (typically every day). </br>
+     * Set this to false if no auto refill is expected e.g. account contains static amount of bought traffic so once used up, the account
+     * stays empty.
+     */
     public void setTrafficRefill(boolean account_trafficRefill) {
         this.account_trafficRefill = account_trafficRefill;
     }
@@ -499,9 +504,9 @@ public List<String> setMultiHostSupportV2(final PluginForHost multiHostPlugin, f
                 plugins.add(hit);
             }
         }
-        final List<String> finalresults = new ArrayList<String>();
+        final List<String> finalresults_old = new ArrayList<String>();
         /* TODO: Return this once refactoring is done. */
-        final List<MultiHostHost> finalresults2 = new ArrayList<MultiHostHost>();
+        final List<MultiHostHost> finalresults_new = new ArrayList<MultiHostHost>();
         final HashSet<String> unassignedMultiHostSupport = new HashSet<String>();
         cleanListLoop: for (final Entry<String, MultiHostHost> entry : cleanList.entrySet()) {
             final String maindomainCleaned = entry.getKey();
@@ -510,14 +515,14 @@ public List<String> setMultiHostSupportV2(final PluginForHost multiHostPlugin, f
             if (plugins == null) {
                 mhost.setStatus(MultihosterHostStatus.DEACTIVATED_JDOWNLOADER_UNSUPPORTED);
                 unassignedMultiHostSupport.add(maindomainCleaned);
-                finalresults2.add(mhost);
+                finalresults_new.add(mhost);
                 continue cleanListLoop;
             }
             /* Remove dupes based on the results we already have */
             final Iterator<LazyHostPlugin> iterator = plugins.iterator();
             do {
                 final LazyHostPlugin plugin = iterator.next();
-                if (finalresults.contains(plugin.getHost())) {
+                if (finalresults_old.contains(plugin.getHost())) {
                     plugins.remove(plugin);
                 }
             } while (iterator.hasNext());
@@ -576,22 +581,22 @@ public List<String> setMultiHostSupportV2(final PluginForHost multiHostPlugin, f
             if (printNonWorkingHosts && !hostIsWorkingAccordingToMultihost) {
                 logger.info("Non working host: " + mhost);
             }
-            if (!DebugMode.TRUE_IN_IDE_ELSE_FALSE && !hostIsWorkingAccordingToMultihost) {
-                // TODO: Remove this check
-                logger.info("Skipping non working host in stable: " + mhost.getName());
-                continue cleanListLoop;
-            }
             final String pluginHost = finalplugin.getHost();
             if (multiHostPlugin != null && pluginHost.equals(multiHostPlugin.getHost())) {
                 /*
-                 * Some mmultihosts put their own domain in the list of supported hosts. However, this is nowhere needed so let's not add it
+                 * Some multihosts put their own domain in the list of supported hosts. However, this is nowhere needed so let's not add it
                  * to the final list.
                  */
                 continue cleanListLoop;
-            } else if (finalresults.contains(pluginHost)) {
+            } else if (finalresults_old.contains(pluginHost)) {
                 continue cleanListLoop;
             }
-            finalresults.add(pluginHost);
+            if (!DebugMode.TRUE_IN_IDE_ELSE_FALSE && !hostIsWorkingAccordingToMultihost) {
+                // TODO: Remove this check
+                logger.info("Skipping non working host in stable: " + mhost.getName());
+            } else {
+                finalresults_old.add(pluginHost);
+            }
             final String[] siteSupportedNames = finalplugin.getSitesSupported();
             if (siteSupportedNames != null && siteSupportedNames.length > 0) {
                 /* Add all domains we know to list of supported domains. */
@@ -603,7 +608,7 @@ public List<String> setMultiHostSupportV2(final PluginForHost multiHostPlugin, f
             /* Set plugin domain as first domain */
             mhost.getDomains().remove(pluginHost);
             mhost.getDomains().add(0, pluginHost);
-            finalresults2.add(mhost);
+            finalresults_new.add(mhost);
         }
         /**
          * Remove all "double" entries from remaining list of unmatched entries to avoid wrong log output. </br>
@@ -647,7 +652,7 @@ public List<String> setMultiHostSupportV2(final PluginForHost multiHostPlugin, f
                 }
             }
         }
-        if (finalresults.isEmpty()) {
+        if (finalresults_old.isEmpty()) {
             if (logger != null) {
                 logger.info("Failed to find ANY usable results");
             }
@@ -657,24 +662,24 @@ public List<String> setMultiHostSupportV2(final PluginForHost multiHostPlugin, f
         /* Log final results if wanted. */
         final boolean logValidResults = false;
         if (logger != null && logValidResults) {
-            logger.info("Found real hosts: " + finalresults.size());
-            for (final String host : finalresults) {
+            logger.info("Found real hosts: " + finalresults_old.size());
+            for (final String host : finalresults_old) {
                 logger.finest("Found host: " + host);
             }
         }
         /* sorting will now work properly since they are all pre-corrected to lowercase. */
-        Collections.sort(finalresults, new NaturalOrderComparator());
-        this.setProperty(PROPERTY_MULTIHOST_SUPPORT, new CopyOnWriteArrayList<String>(finalresults));
+        Collections.sort(finalresults_old, new NaturalOrderComparator());
+        this.setProperty(PROPERTY_MULTIHOST_SUPPORT, new CopyOnWriteArrayList<String>(finalresults_old));
         if (DebugMode.TRUE_IN_IDE_ELSE_FALSE) {
-            Collections.sort(finalresults2, new Comparator<MultiHostHost>() {
+            Collections.sort(finalresults_new, new Comparator<MultiHostHost>() {
                 @Override
                 public int compare(MultiHostHost o1, MultiHostHost o2) {
                     return o1.getDomain().compareToIgnoreCase(o2.getDomain());
                 }
             });
-            multihostSupportV2 = new CopyOnWriteArrayList<MultiHostHost>(finalresults2);
+            multihostSupportV2 = new CopyOnWriteArrayList<MultiHostHost>(finalresults_new);
         }
-        return finalresults;
+        return finalresults_old;
     }
 
     protected List<MultiHostHost> multihostSupportV2 = null;