private final long ipsBlocked;
        private final int activeAccounts;
        private final int activeIps;

        public RateLimiterStats(long totalBlocked, long accountsLocked, long ipsBlocked, int activeAccounts, int activeIps) {
            this.totalBlocked = totalBlocked;
            this.accountsLocked = accountsLocked;
            this.ipsBlocked = ipsBlocked;

            sb.append(", update => ").append(releases.getUpdatePolicy()).append(']');
        }

        sb.append("   blocked: ").append(isBlocked()).append('\n');

        return sb.toString();
    }

    @Override
    public Artifact find(Artifact artifact) {
        File artifactFile = new File(getBasedir(), pathOf(artifact));

    void awaitWaiting() {
      while (!isBlocked()) {
        if (getState() == State.TERMINATED) {
          throw new RuntimeException("Thread exited");
        }
        Thread.yield();
      }
    }

    private boolean isBlocked() {
      return getState() == Thread.State.WAITING && LockSupport.getBlocker(this) == future;
    }
  }

    void awaitWaiting() {
      while (!isBlocked()) {
        if (getState() == State.TERMINATED) {
          throw new RuntimeException("Thread exited");
        }
        Thread.yield();
      }
    }

    private boolean isBlocked() {
      return getState() == Thread.State.WAITING && LockSupport.getBlocker(this) == future;
    }
  }

            return Collections.emptyList();
        }

        @Override
        public void setMirroredRepositories(List<ArtifactRepository> mirroredRepositories) {}

        @Override
        public boolean isBlocked() {
            return false;
        }

        @Override
        public void setBlocked(boolean blocked) {}
    }

        sb.append("id=").append(this.getId());
        sb.append(",mirrorOf=").append(this.getMirrorOf());
        sb.append(",url=").append(this.getUrl());
        sb.append(",name=").append(this.getName());
        if (isBlocked()) {
            sb.append(",blocked");
        }
        sb.append("]");
        return sb.toString();
    }
            ]]>
          </code>
        </codeSegment>
      </codeSegments>

                    mirror.setId(repo.getId());
                    mirror.setUrl(repo.getUrl());
                    mirror.setLayout(repo.getContentType());
                    mirror.setBlocked(repo.isBlocked());
                    return mirror;
                }
            }
        }
        return null;
    }

            effectiveRepository.setProxy(aliasedRepo.getProxy());

            effectiveRepository.setMirroredRepositories(mirroredRepos);

            effectiveRepository.setBlocked(aliasedRepo.isBlocked());

            effectiveRepositories.add(effectiveRepository);
        }

        return effectiveRepositories;
    }

            builder.setProxy(toProxy(repo.getProxy()));
            builder.setMirroredRepositories(toRepos(repo.getMirroredRepositories()));
            builder.setBlocked(repo.isBlocked());
            result = builder.build();
        }
        return result;
    }

    public static String getLayout(ArtifactRepository repo) {
        try {
            return repo.getLayout().getId();

            mirrorSelector.add(
                    mirror.getId(),
                    mirror.getUrl(),
                    mirror.getLayout(),
                    false,
                    mirror.isBlocked(),
                    mirror.getMirrorOf(),
                    mirror.getMirrorOfLayouts());
        }
        sessionBuilder.setMirrorSelector(mirrorSelector);