Quando maven diz que "a resolução não será tentada até que o intervalo de atualização do MyRepo tenha decorrido", onde esse intervalo foi especificado?

Com o maven, ocasionalmente encontro um artefato proveniente de algum repositório de terceiros que ainda não construí ou incluí no meu repositório.

Receberei uma mensagem de erro do cliente maven dizendo que um artefato não pode ser encontrado:

Falha ao localizar org.jfrog.maven.annomojo: maven-plugin-anno: jar: 1.4.0 in http://myrepo:80/artifactory/repofoi armazenado em cache no repositório local, a resolução não será tentada até que o intervalo de atualização do MyRepo tenha decorrido ou as atualizações sejam forçadas -> [ Ajuda 1]

Agora, eu entendo o que isso significa, e pode simplesmente re-executar o meu comando com -U, e as coisas normalmente funcionará bem de lá em diante .

No entanto, acho esta mensagem de erro extremamente intuitiva e estou tentando poupar alguns dos meus colegas de trabalho.

Estou tentando descobrir se há algum lugar para modificar essa update intervalconfiguração.

1. O update intervalmencionado nesta mensagem de erro é uma configuração do lado do cliente ou do servidor?
2. Se do lado do cliente, como faço para configurá-lo?
3. No lado do servidor, alguém sabe como / se o Nexus / Artifactory expõe essas configurações?

Eu costumava resolver esse problema excluindo a pasta correspondente ao download de artefato correspondente no repositório local. Na próxima vez em que executar o comando maven, o download do artefato é acionado novamente. Portanto, eu diria que é uma configuração do lado do cliente.

No lado do Nexus (lado do repo do servidor), esse problema foi resolvido na configuração de uma tarefa agendada. Do lado do cliente, isso é feito usando -U, como você já apontou.

você pode excluir o diretório de artefato com falha correspondente em seu repositório local. E também você pode simplesmente usar o -Uno objetivo. Isso fará o trabalho. Isso funciona com o maven 3. Portanto, não é necessário fazer o downgrade para o maven 2.

Eu tive um problema relacionado, mas a resposta de Raghuram ajudou. (Ainda não tenho reputação suficiente para votar em sua resposta). Estou usando o Maven empacotado com o NetBeans e estava obtendo o mesmo "... foi armazenado em cache no repositório local, a resolução não será tentada até que o intervalo de atualização do nexus tenha decorrido ou as atualizações sejam forçadas -> erro [Ajuda 1]" .

Para corrigir isso, adicionei <updatePolicy>always</updatePolicy>ao meu arquivo de configurações (C: \ Arquivos de Programas \ NetBeans 7.0 \ java \ maven \ conf \ settings.xml)

<profile>
  <id>nexus</id>
  <!--Enable snapshots for the built in central repo to direct -->
  <!--all requests to nexus via the mirror -->
  <repositories>
    <repository>
      <id>central</id>
      <url>http://central</url>
      <releases><enabled>true</enabled><updatePolicy>always</updatePolicy></releases>
      <snapshots><enabled>true</enabled><updatePolicy>always</updatePolicy></snapshots>
    </repository>
  </repositories>
 <pluginRepositories>
    <pluginRepository>
      <id>central</id>
      <url>http://central</url>
      <releases><enabled>true</enabled><updatePolicy>always</updatePolicy></releases>
      <snapshots><enabled>true</enabled><updatePolicy>always</updatePolicy></snapshots>
    </pluginRepository>
  </pluginRepositories>
</profile>

O que basicamente acontece é que, de acordo com a política de atualização padrão do maven.

Resolução:

Qualquer uso

mvn -U clean install

onde -U forçará a atualização do repositório

ou use

<profiles>
    <profile>
      ...
      <repositories>
        <repository>
          <id>myRepo</id>
          <name>My Repository</name>
          <releases>
            <enabled>false</enabled>
            <updatePolicy>always</updatePolicy>
            <checksumPolicy>warn</checksumPolicy>
          </releases>
         </repository>
      </repositories>
      ...
    </profile>
  </profiles>

no seu settings.xml

De acordo com a referência de configurações :

updatePolicy: Este elemento especifica com que frequência as atualizações devem tentar ocorrer. O Maven comparará o registro de data e hora do POM local (armazenado no arquivo de metadados de um repositório) com o controle remoto. As opções são: sempre, diariamente (padrão), intervalo: X (onde X é um número inteiro em minutos) ou nunca.

Exemplo:

<profiles>
    <profile>
      ...
      <repositories>
        <repository>
          <id>myRepo</id>
          <name>My Repository</name>
          <releases>
            <enabled>false</enabled>
            <updatePolicy>always</updatePolicy>
            <checksumPolicy>warn</checksumPolicy>
          </releases>
         </repository>
      </repositories>
      ...
    </profile>
  </profiles>
  ...
</settings>

Embora você possa resolver isso com uma instalação limpa (substituindo quaisquer dependências em cache), como @ Sanjeev-Gulgani sugere com mvn -U clean install

Você também pode simplesmente remover a dependência em cache que está causando o problema com

mvn dependency:purge-local-repository -DmanualInclude="groupId:artifactId"

Veja mvn docs para mais informações.

Às vezes, esse erro pode ser enganoso. 2 coisas que você pode querer verificar:

1. Existe um JAR real para a dependência no repositório? Sua mensagem de erro contém um URL de onde está pesquisando; portanto, vá para lá e navegue até a pasta que corresponde à sua dependência. Existe uma jarra? Caso contrário, você precisará alterar sua dependência. (por exemplo, você poderia estar apontando para uma dependência pai de nível superior, quando deveria estar apontando para um subprojeto)

2. Se o jar existir no repositório remoto, exclua sua cópia local. Ele estará em seu diretório pessoal (a menos que você tenha configurado de maneira diferente) em .m2 / repository (ls -a para mostrar oculto se estiver no Linux).

Se você estiver usando o Eclipse, acesse Windows -> Preferências -> Maven e desmarque a caixa de seleção "Não atualizar automaticamente dependências de repositórios remotos".

Isso funciona com o Maven 3 também.

Você precisa excluir todos os arquivos "_maven.repositories" do seu repositório.

Isso funciona depois que você exclui a dependência relacionada do seu repositório maven local

/user/.m2/repository/path

Se você usar o Nexus como um repositório de proxy, ele terá a configuração "TTL de cache não encontrado" com o valor padrão 1440 minutos (ou 24 horas). A redução desse valor pode ajudar (Repositórios> Configuração> Configurações de Expiração).

Consulte a documentação para obter mais informações.

Como eu consegui esse problema,

Quando mudei do Eclipse Juno para Luna e fiz check-out dos meus projetos do repositório SVN, tive os mesmos problemas ao criar os aplicativos.

O que eu tentei? Tentei limpar o repositório local e atualizei todas as versões novamente usando a opção -U. Mas meu problema continuou.

Depois fui para Janela -> Preferências -> Maven -> Configurações do usuário -> e cliquei no botão Reindex em Repositório local e aguarde a reindexação.

Isso é tudo, o problema está resolvido.

Para finalmente responder à pergunta do título: É (uma configuração do lado do cliente) em (projeto, perfil ou configurações)

[plugin]?[r|R]epository/[releases|snapshots]/updatePolicy

... tag.

Os (atualmente, maven: 3.6.0, mas suponho que sejam compatíveis "muito atrás") os possíveis valores são:

/**
 * Never update locally cached data.
 */
public static final String UPDATE_POLICY_NEVER = "never";
/**
 * Always update locally cached data.
 */
public static final String UPDATE_POLICY_ALWAYS = "always";
/**
 * Update locally cached data once a day.
 */
public static final String UPDATE_POLICY_DAILY = "daily";
/**
 * Update locally cached data **every X minutes** as given by "interval:X".
 */
public static final String UPDATE_POLICY_INTERVAL = "interval";

A avaliação atual (maven 3.6.0) dessa tag é implementada da seguinte maneira:

public boolean isUpdatedRequired( RepositorySystemSession session, long lastModified, String policy )
{
    boolean checkForUpdates;
    if ( policy == null )
    {
        policy = "";
    }
    if ( RepositoryPolicy.UPDATE_POLICY_ALWAYS.equals( policy ) )
    {
        checkForUpdates = true;
    }
    else if ( RepositoryPolicy.UPDATE_POLICY_DAILY.equals( policy ) )
    {
        Calendar cal = Calendar.getInstance();
        cal.set( Calendar.HOUR_OF_DAY, 0 );
        cal.set( Calendar.MINUTE, 0 );
        cal.set( Calendar.SECOND, 0 );
        cal.set( Calendar.MILLISECOND, 0 );
        checkForUpdates = cal.getTimeInMillis() > lastModified;
    }
    else if ( policy.startsWith( RepositoryPolicy.UPDATE_POLICY_INTERVAL ) )
    {
        int minutes = getMinutes( policy );
        Calendar cal = Calendar.getInstance();
        cal.add( Calendar.MINUTE, -minutes );
        checkForUpdates = cal.getTimeInMillis() > lastModified;
    }
    else
    {
        // assume "never"
        checkForUpdates = false;
        if ( !RepositoryPolicy.UPDATE_POLICY_NEVER.equals( policy ) )
        {
            LOGGER.warn( "Unknown repository update policy '{}', assuming '{}'",
                    policy, RepositoryPolicy.UPDATE_POLICY_NEVER );
        }
    }
    return checkForUpdates;
}

..com:

private int getMinutes( String policy )
{
    int minutes;
    try
    {
        String s = policy.substring( RepositoryPolicy.UPDATE_POLICY_INTERVAL.length() + 1 );
        minutes = Integer.valueOf( s );
    }
    catch ( RuntimeException e )
    {
        minutes = 24 * 60;
        LOGGER.warn( "Non-parseable repository update policy '{}', assuming '{}:1440'",
                policy, RepositoryPolicy.UPDATE_POLICY_INTERVAL );
    }
    return minutes;
}

... onde lastModifiedestá o (arquivo local) "carimbo de data / hora modificado" de um / cada artefato subjacente.

Em particular para a interval:xconfiguração:

• o cólon :não é tão rigoroso - qualquer caractere "não vazio" poderia fazer isso ( =, ...).
• valores negativos x < 0devem render para "nunca".
• interval:0 Eu assumiria um intervalo "minucioso" (0-59 segundos ou mais ...).
• as exceções de formato numérico resultam em 24 * 60minutos (~ "diariamente").

..see: DefaultUpdatePolicyAnalyzer , DefaultMetadataResolver # resolveMetadata () e RepositoryPolicy

Para usuários do Intellij, o seguinte funcionou para mim:

Clique com o botão direito no seu pacote

Maven > Reimport 

e

Maven > Generate Sources and Update Folders

Um pouco relevante .. eu estava ficando

"[ERRO] Falha ao executar o objetivo no projeto testproject: Não foi possível resolver dependências do projeto myjarname: jar: 1.0-0: Falha ao localizar myjarname-core: bundle: 1.0-0 em http://repo1.maven.org/maven2cache no repositório local, a resolução não será tente novamente até que o intervalo de atualização da central tenha decorrido ou que as atualizações sejam forçadas -> [Ajuda 1] "

Este erro foi causado pelo uso acidental em Maven 3vez de Maven 2. Imaginei que poderia economizar tempo para alguém, porque minha pesquisa inicial no Google me levou a esta página.

O Maven possui configurações updatePolicy para especificar a frequência para verificar as atualizações no repositório ou para manter o repositório sincronizado com remoto.

• O valor padrão para updatePolicy é diário.
• Outros valores podem ser sempre / nunca / XX (especificando o intervalo em minutos).

O exemplo de código abaixo pode ser adicionado ao arquivo de configurações do usuário maven para configurar o updatePolicy.

<pluginRepositories>
    <pluginRepository>
        <id>Releases</id>
        <url>http://<host>:<port>/nexus/content/repositories/releases/</url>
        <releases>
            <enabled>true</enabled>
            <updatePolicy>daily</updatePolicy>
        </releases>
        <snapshots>
            <enabled>false</enabled>
        </snapshots>
    </pluginRepository>             
</pluginRepositories>

No meu caso, a solução foi estúpida: eu só tinha versões de dependência incorretas.

Eu tive esse problema e as descrições abrangentes propostas nisso me ajudaram a corrigi-lo.

O segundo problema declarado foi o meu problema. Eu usei um repositório de terceiros que acabei de adicionar para fazer a repositoryparte do arquivo pom no meu projeto. Eu adiciono as mesmas informações do repositório pluginrepositorypara resolver esse problema.

Eu tive um erro semelhante com um artefato diferente.

<...> foi armazenado em cache no repositório local, a resolução não será tentada novamente até que o intervalo de atualização da central tenha decorrido ou que as atualizações sejam forçadas

Nenhuma das soluções descritas acima funcionou para mim. Finalmente resolvi isso no IntelliJ IDEA por Arquivo> Invalidar caches / reiniciar ...> Invalidar e reiniciar .

No meu caso, eu tinha vários projetos

rootProject
 |-> contractProject (using Project Lombok)
 |-> domainProject (dependency on contractProject)

Quando eu fiz "mvn clean install" no diretório "domainProject", recebi o erro.

Quando eu "mvn clean install" do diretório "projectRoot", o problema foi resolvido.