import org.eclipse.aether.deployment.DeploymentException; //导入依赖的package包/类
@Override
public void execute(ExecutionContext context) throws MojoExecutionException, MojoFailureException {
  this.log.info("Deploying the release artifacts into the distribution repository");

  try {
    Collection<Artifact> deployedArtifacts = this.deployer.deployArtifacts(this.metadata.getReleaseArtifacts());
    if (!deployedArtifacts.isEmpty()) {
      this.log.debug("\tDeployed the following release artifacts to the remote repository:");
      for (Artifact a : deployedArtifacts) {
        this.log.debug("\t\t" + a);
      }
    }
  } catch (DeploymentException e) {
    throw new MojoFailureException("Unable to deploy artifacts into remote repository.", e);
  }
}
 

import org.eclipse.aether.deployment.DeploymentException; //导入依赖的package包/类
@Override
public void deploy(final String pom,
                   final Artifact... artifacts) {
    try {
        final DeployRequest deployRequest = new DeployRequest();

        for (Artifact artifact : artifacts) {
            deployRequest.addArtifact(artifact);
        }

        deployRequest.setRepository(getRepository());

        Aether.getAether().getSystem().deploy(Aether.getAether().getSession(),
                                              deployRequest);
    } catch (DeploymentException e) {
        throw new RuntimeException(e);
    }
}
 

import org.eclipse.aether.deployment.DeploymentException; //导入依赖的package包/类
/**
 * @param descriptor an {@link Artifact}, holding the maven coordinates for the published files
 *     less the extension that is to be derived from the files. The {@code descriptor} itself will
 *     not be published as is, and the {@link File} attached to it (if any) will be ignored.
 * @param toPublish {@link File}(s) to be published using the given coordinates. The filename
 *     extension of each given file will be used as a maven "extension" coordinate
 */
public DeployResult publish(Artifact descriptor, List<File> toPublish)
    throws DeploymentException {
  String providedExtension = descriptor.getExtension();
  if (!providedExtension.isEmpty()) {
    LOG.warn(
        "Provided extension %s of artifact %s to be published will be ignored. The extensions "
            + "of the provided file(s) will be used",
        providedExtension, descriptor);
  }
  List<Artifact> artifacts = new ArrayList<>(toPublish.size());
  for (File file : toPublish) {
    artifacts.add(
        new SubArtifact(
            descriptor,
            descriptor.getClassifier(),
            Files.getFileExtension(file.getAbsolutePath()),
            file));
  }
  return publish(artifacts);
}
 

import org.eclipse.aether.deployment.DeploymentException; //导入依赖的package包/类
/**
 * Deploys the given artifacts to the configured remote Maven repositories.
 *
 * @param artifacts the artifacts to deploy.
 * @return the artifacts that have been deployed successfully.
 * @throws DeploymentException if anything goes wrong during the deployment process.
 */
public Collection<Artifact> deployArtifacts(Collection<Artifact> artifacts) throws DeploymentException {
  DeployRequest request = new DeployRequest();
  request.setArtifacts(artifacts);
  request.setRepository(this.metadata.getDeploymentRepository());
  DeployResult result = this.deployer.deploy(this.repoSession, request);
  return result.getArtifacts();
}
 

import org.eclipse.aether.deployment.DeploymentException; //导入依赖的package包/类
private DeployResult deployUsingAether(Artifact artifact, Artifact pom, RemoteRepository deploymentRepository) throws DeploymentException {
	RepositorySystem system = aetherConfigurer.newRepositorySystem();
	RepositorySystemSession session = aetherConfigurer.newSession(system, mvnConsumerConfigurer.getLocalM2Repo());
	DeployRequest deployRequest = new DeployRequest();
	deployRequest.addArtifact(artifact).addArtifact(pom);
	deployRequest.setRepository(deploymentRepository);
	DeployResult result = system.deploy(session, deployRequest);
	return result;
}
 

import org.eclipse.aether.deployment.DeploymentException; //导入依赖的package包/类
@Override
public void afterSessionEnd(MavenSession session) throws MavenExecutionException {
  boolean errors = !session.getResult().getExceptions().isEmpty();

  if (!deployAtEndRequests.isEmpty()) {

    log.info("");
    log.info("------------------------------------------------------------------------");

    if (errors) {
      log.info("-- Not performing deploy at end due to errors                         --");
    } else {
      log.info("-- Performing deploy at end                                           --");
      log.info("------------------------------------------------------------------------");

      synchronized (deployAtEndRequests) {
        for (DeployRequest deployRequest : deployAtEndRequests) {
          try {
            deploy(session.getRepositorySession(), deployRequest);
          } catch (DeploymentException e) {
            log.error(e.getMessage(), e);
            throw new MavenExecutionException(e.getMessage(), e);
          }
        }
        deployAtEndRequests.clear();
      }
    }

    log.info("------------------------------------------------------------------------");
  }
}
 

import org.eclipse.aether.deployment.DeploymentException; //导入依赖的package包/类
/**
 * Deploy each of the provided {@link Module}s, along with their SubArtifacts (POMs, JavaDoc bundle, etc.), to the repository location
 * indicated by {@link #repositoryUrl}.
 */
@Override 
public void doExecute(Set<Module> artifacts) throws MojoExecutionException, MojoFailureException {

   	RemoteRepository.Builder builder = new RemoteRepository.Builder(repositoryId, repositoryType, repositoryUrl);
	Authentication authentication = getAuthentication(repositoryId);
   	builder.setAuthentication(authentication);

   	LOGGER.info("Deploying to repositoryId '{}' with credentials: {}", repositoryId, authentication == null ? null : authentication.toString());
   	
   	RemoteRepository repository = builder.build();
	
	for (Module artifact : artifacts) {
     
		DeployRequest deployRequest = new DeployRequest();
		deployRequest.addArtifact(artifact); 
       	deployRequest.setRepository(repository);
       	
		for (Artifact subArtifact : artifact.getAttachments()) {
        	deployRequest.addArtifact(subArtifact);
        }
        
        try {
			repositorySystem.deploy(repositorySystemSession, deployRequest);
		} catch (DeploymentException e) {
			throw new MojoFailureException("Deployment failed: ", e);
		}	

	}		
}
 

import org.eclipse.aether.deployment.DeploymentException; //导入依赖的package包/类
/** convenience method */
public void deploy(RemoteRepository target, Artifact ... artifacts) throws DeploymentException {
    deploy(target, null, Arrays.asList(artifacts));
}
 

import org.eclipse.aether.deployment.DeploymentException; //导入依赖的package包/类
public void deploy(RepositorySystemSession session, DeployRequest deployRequest) throws DeploymentException {
  repoSystem.deploy(session, deployRequest);
}
 

import org.eclipse.aether.deployment.DeploymentException; //导入依赖的package包/类
private boolean publishTargets(
    ImmutableList<BuildTarget> buildTargets, CommandRunnerParams params) {
  ImmutableSet.Builder<MavenPublishable> publishables = ImmutableSet.builder();
  boolean success = true;
  for (BuildTarget buildTarget : buildTargets) {
    BuildRule buildRule = getBuild().getRuleResolver().requireRule(buildTarget);
    Preconditions.checkNotNull(buildRule);

    if (!(buildRule instanceof MavenPublishable)) {
      params
          .getBuckEventBus()
          .post(
              ConsoleEvent.severe(
                  "Cannot publish rule of type %s", buildRule.getClass().getName()));
      success &= false;
      continue;
    }

    MavenPublishable publishable = (MavenPublishable) buildRule;
    if (!publishable.getMavenCoords().isPresent()) {
      params
          .getBuckEventBus()
          .post(
              ConsoleEvent.severe(
                  "No maven coordinates specified for %s",
                  buildTarget.getUnflavoredBuildTarget().getFullyQualifiedName()));
      success &= false;
      continue;
    }
    publishables.add(publishable);
  }

  Publisher publisher =
      new Publisher(
          params.getCell().getFilesystem(),
          Optional.ofNullable(remoteRepo),
          Optional.ofNullable(username),
          Optional.ofNullable(password),
          dryRun);

  try {
    ImmutableSet<DeployResult> deployResults =
        publisher.publish(
            DefaultSourcePathResolver.from(
                new SourcePathRuleFinder(getBuild().getRuleResolver())),
            publishables.build());
    for (DeployResult deployResult : deployResults) {
      printArtifactsInformation(params, deployResult);
    }
  } catch (DeploymentException e) {
    params.getConsole().printBuildFailureWithoutStacktraceDontUnwrap(e);
    return false;
  }
  return success;
}
 

import org.eclipse.aether.deployment.DeploymentException; //导入依赖的package包/类
@Test
public void errorRaisedForDuplicateFirstOrderDeps()
    throws DeploymentException, NoSuchBuildTargetException {
  // Construct a graph that looks like this.  A and B have maven coordinates set.
  // A   B
  //  \ /
  //   C
  BuildTarget publishableTargetA =
      BuildTargetFactory.newInstance("//:a").withFlavors(JavaLibrary.MAVEN_JAR);
  BuildTarget publishableTargetB =
      BuildTargetFactory.newInstance("//:b").withFlavors(JavaLibrary.MAVEN_JAR);
  BuildTarget targetC = BuildTargetFactory.newInstance("//:c");

  TargetNode<?, ?> depNode =
      JavaLibraryBuilder.createBuilder(targetC).addSrc(Paths.get("c.java")).build();
  TargetNode<?, ?> publishableANode =
      JavaLibraryBuilder.createBuilder(publishableTargetA)
          .addSrc(Paths.get("a.java"))
          .setMavenCoords(MVN_COORDS_A)
          .addDep(targetC)
          .build();
  TargetNode<?, ?> publishableBNode =
      JavaLibraryBuilder.createBuilder(publishableTargetB)
          .addSrc(Paths.get("b.java"))
          .setMavenCoords(MVN_COORDS_B)
          .addDep(targetC)
          .build();

  TargetGraph targetGraph =
      TargetGraphFactory.newInstance(depNode, publishableANode, publishableBNode);
  BuildRuleResolver resolver =
      new SingleThreadedBuildRuleResolver(
          targetGraph, new DefaultTargetNodeToBuildRuleTransformer());
  SourcePathResolver pathResolver =
      DefaultSourcePathResolver.from(new SourcePathRuleFinder(resolver));

  MavenPublishable publishableA = (MavenPublishable) resolver.requireRule(publishableTargetA);
  MavenPublishable publishableB = (MavenPublishable) resolver.requireRule(publishableTargetB);

  expectedException.expect(DeploymentException.class);
  expectedException.expectMessage(
      Matchers.containsString(targetC.getUnflavoredBuildTarget().getFullyQualifiedName()));
  expectedException.expectMessage(
      Matchers.containsString(
          publishableTargetA.getUnflavoredBuildTarget().getFullyQualifiedName()));
  expectedException.expectMessage(
      Matchers.containsString(
          publishableTargetB.getUnflavoredBuildTarget().getFullyQualifiedName()));

  publisher.publish(pathResolver, ImmutableSet.of(publishableA, publishableB));
}
 

import org.eclipse.aether.deployment.DeploymentException; //导入依赖的package包/类
@Test
public void errorRaisedForDuplicateFirstOrderAndTransitiveDep()
    throws DeploymentException, NoSuchBuildTargetException {
  // Construct a graph that looks like this.  A and B have maven coordinates set.
  // A   B
  // |   |
  // C   |
  //  \ /
  //   D
  BuildTarget publishableTargetA =
      BuildTargetFactory.newInstance("//:a").withFlavors(JavaLibrary.MAVEN_JAR);
  BuildTarget publishableTargetB =
      BuildTargetFactory.newInstance("//:b").withFlavors(JavaLibrary.MAVEN_JAR);
  BuildTarget targetC = BuildTargetFactory.newInstance("//:c");
  BuildTarget targetD = BuildTargetFactory.newInstance("//:d");

  TargetNode<?, ?> transitiveDepNode =
      JavaLibraryBuilder.createBuilder(targetD).addSrc(Paths.get("d.java")).build();
  TargetNode<?, ?> depNode =
      JavaLibraryBuilder.createBuilder(targetC)
          .addSrc(Paths.get("c.java"))
          .addDep(targetD)
          .build();
  TargetNode<?, ?> publishableANode =
      JavaLibraryBuilder.createBuilder(publishableTargetA)
          .addSrc(Paths.get("a.java"))
          .setMavenCoords(MVN_COORDS_A)
          .addDep(targetC)
          .build();
  TargetNode<?, ?> publishableBNode =
      JavaLibraryBuilder.createBuilder(publishableTargetB)
          .addSrc(Paths.get("b.java"))
          .setMavenCoords(MVN_COORDS_B)
          .addDep(targetD)
          .build();

  TargetGraph targetGraph =
      TargetGraphFactory.newInstance(
          transitiveDepNode, depNode, publishableANode, publishableBNode);
  BuildRuleResolver resolver =
      new SingleThreadedBuildRuleResolver(
          targetGraph, new DefaultTargetNodeToBuildRuleTransformer());
  SourcePathResolver pathResolver =
      DefaultSourcePathResolver.from(new SourcePathRuleFinder(resolver));

  MavenPublishable publishableA = (MavenPublishable) resolver.requireRule(publishableTargetA);
  MavenPublishable publishableB = (MavenPublishable) resolver.requireRule(publishableTargetB);

  expectedException.expect(DeploymentException.class);
  expectedException.expectMessage(
      Matchers.containsString(targetD.getUnflavoredBuildTarget().getFullyQualifiedName()));
  expectedException.expectMessage(
      Matchers.containsString(
          publishableTargetA.getUnflavoredBuildTarget().getFullyQualifiedName()));
  expectedException.expectMessage(
      Matchers.containsString(
          publishableTargetB.getUnflavoredBuildTarget().getFullyQualifiedName()));

  publisher.publish(pathResolver, ImmutableSet.of(publishableA, publishableB));
}
 

import org.eclipse.aether.deployment.DeploymentException; //导入依赖的package包/类
@Test
public void errorRaisedForDuplicateTransitiveDeps()
    throws DeploymentException, NoSuchBuildTargetException {
  // Construct a graph that looks like this.  A and B have maven coordinates set.
  // A   B
  // |   |
  // C   D
  //  \ /
  //   E
  BuildTarget publishableTargetA =
      BuildTargetFactory.newInstance("//:a").withFlavors(JavaLibrary.MAVEN_JAR);
  BuildTarget publishableTargetB =
      BuildTargetFactory.newInstance("//:b").withFlavors(JavaLibrary.MAVEN_JAR);
  BuildTarget targetC = BuildTargetFactory.newInstance("//:c");
  BuildTarget targetD = BuildTargetFactory.newInstance("//:d");
  BuildTarget targetE = BuildTargetFactory.newInstance("//:e");

  TargetNode<?, ?> transitiveDepNode =
      JavaLibraryBuilder.createBuilder(targetE).addSrc(Paths.get("e.java")).build();
  TargetNode<?, ?> dep1Node =
      JavaLibraryBuilder.createBuilder(targetC)
          .addSrc(Paths.get("c.java"))
          .addDep(targetE)
          .build();
  TargetNode<?, ?> dep2Node =
      JavaLibraryBuilder.createBuilder(targetD)
          .addSrc(Paths.get("d.java"))
          .addDep(targetE)
          .build();
  TargetNode<?, ?> publishableANode =
      JavaLibraryBuilder.createBuilder(publishableTargetA)
          .addSrc(Paths.get("a.java"))
          .setMavenCoords(MVN_COORDS_A)
          .addDep(targetC)
          .build();
  TargetNode<?, ?> publishableBNode =
      JavaLibraryBuilder.createBuilder(publishableTargetB)
          .addSrc(Paths.get("b.java"))
          .setMavenCoords(MVN_COORDS_B)
          .addDep(targetD)
          .build();

  TargetGraph targetGraph =
      TargetGraphFactory.newInstance(
          transitiveDepNode, dep1Node, dep2Node, publishableANode, publishableBNode);
  BuildRuleResolver resolver =
      new SingleThreadedBuildRuleResolver(
          targetGraph, new DefaultTargetNodeToBuildRuleTransformer());
  SourcePathResolver pathResolver =
      DefaultSourcePathResolver.from(new SourcePathRuleFinder(resolver));

  MavenPublishable publishableA = (MavenPublishable) resolver.requireRule(publishableTargetA);
  MavenPublishable publishableB = (MavenPublishable) resolver.requireRule(publishableTargetB);

  expectedException.expect(DeploymentException.class);
  expectedException.expectMessage(
      Matchers.containsString(targetE.getUnflavoredBuildTarget().getFullyQualifiedName()));
  expectedException.expectMessage(
      Matchers.containsString(
          publishableTargetA.getUnflavoredBuildTarget().getFullyQualifiedName()));
  expectedException.expectMessage(
      Matchers.containsString(
          publishableTargetB.getUnflavoredBuildTarget().getFullyQualifiedName()));

  publisher.publish(pathResolver, ImmutableSet.of(publishableA, publishableB));
}