import org.apache.maven.settings.Settings; //导入依赖的package包/类
/**
 * if the repository has a mirror, then create a repositoryinfo object for it..
 */

private RepositoryInfo getMirrorInfo(RepositoryInfo info, MirrorSelector selector, Settings settings) {
    RemoteRepository original = new RemoteRepository.Builder(info.getId(), /* XXX do we even support any other layout?*/"default", info.getRepositoryUrl()).build();
    RemoteRepository mirror = selector.getMirror(original);
    if (mirror != null) {
        try {
            String name = mirror.getId();
            //#213078 need to lookup name for mirror
            for (Mirror m : settings.getMirrors()) {
                if (m.getId() != null && m.getId().equals(mirror.getId())) {
                    name = m.getName();
                    break;
                }
            }
            RepositoryInfo toret = new RepositoryInfo(mirror.getId(), name, null, mirror.getUrl());
            toret.setMirrorStrategy(RepositoryInfo.MirrorStrategy.NONE);
            return toret;
        } catch (URISyntaxException ex) {
            Exceptions.printStackTrace(ex);
        }
    }
    return null;
}
 

import org.apache.maven.settings.Settings; //导入依赖的package包/类
@Test
public void updateAppRuntime() throws Exception {
    final SiteInner siteInner = mock(SiteInner.class);
    doReturn("app,linux").when(siteInner).kind();
    final WithCredentials withCredentials = mock(WithCredentials.class);
    final Update update = mock(Update.class);
    doReturn(withCredentials).when(update).withPrivateRegistryImage(null, null);
    final WebApp app = mock(WebApp.class);
    doReturn(siteInner).when(app).inner();
    doReturn(update).when(app).update();

    final ContainerSetting containerSetting = new ContainerSetting();
    containerSetting.setServerId("serverId");
    doReturn(containerSetting).when(mojo).getContainerSettings();

    final Server server = mock(Server.class);
    final Settings settings = mock(Settings.class);
    doReturn(server).when(settings).getServer(anyString());
    doReturn(settings).when(mojo).getSettings();

    handler.updateAppRuntime(app);

    verify(update, times(1)).withPrivateRegistryImage(null, null);
    verify(server, times(1)).getUsername();
    verify(server, times(1)).getPassword();
}
 

import org.apache.maven.settings.Settings; //导入依赖的package包/类
@Test
public void updateAppRuntime() throws Exception {
    final WebApp app = mock(WebApp.class);
    final SiteInner siteInner = mock(SiteInner.class);
    doReturn("app,linux").when(siteInner).kind();
    doReturn(siteInner).when(app).inner();
    final Update update = mock(Update.class);
    final WithCredentials withCredentials = mock(WithCredentials.class);
    doReturn(withCredentials).when(update).withPrivateDockerHubImage(null);
    doReturn(update).when(app).update();

    final ContainerSetting containerSetting = new ContainerSetting();
    containerSetting.setServerId("serverId");
    doReturn(containerSetting).when(mojo).getContainerSettings();

    final Server server = mock(Server.class);
    final Settings settings = mock(Settings.class);
    doReturn(server).when(settings).getServer(anyString());
    doReturn(settings).when(mojo).getSettings();

    handler.updateAppRuntime(app);

    verify(update, times(1)).withPrivateDockerHubImage(null);
    verify(server, times(1)).getUsername();
    verify(server, times(1)).getPassword();
}
 

import org.apache.maven.settings.Settings; //导入依赖的package包/类
/**
 * Get Authenticated object by referencing server definition in Maven settings.xml
 *
 * @param settings Settings object
 * @param serverId Server Id to search in settings.xml
 * @return Authenticated object if configurations are correct; otherwise return null.
 */
protected Authenticated getAuthObjFromServerId(final Settings settings, final String serverId) {
    if (StringUtils.isEmpty(serverId)) {
        getLog().debug(SERVER_ID_NOT_CONFIG);
        return null;
    }

    final Server server = Utils.getServer(settings, serverId);
    if (server == null) {
        getLog().error(SERVER_ID_NOT_FOUND + serverId);
        return null;
    }

    final ApplicationTokenCredentials credential = getAppTokenCredentialsFromServer(server);
    if (credential == null) {
        getLog().error(AZURE_AUTH_INVALID + serverId);
        return null;
    }

    final Authenticated auth = azureConfigure().authenticate(credential);
    if (auth != null) {
        getLog().info(AUTH_WITH_SERVER_ID + serverId);
    }
    return auth;
}
 

import org.apache.maven.settings.Settings; //导入依赖的package包/类
@Test
public void doExecute() throws Exception {
    final AddMojo mojo = getMojoFromPom();
    final Settings settings = new Settings();
    settings.setInteractiveMode(false);
    ReflectionUtils.setVariableValueInObject(mojo, "basedir", new File("target/test"));
    ReflectionUtils.setVariableValueInObject(mojo, "settings", settings);
    mojo.setFunctionTemplate("HttpTrigger");
    mojo.setFunctionName("New-Function");
    mojo.setFunctionPackageName("com.microsoft.azure");

    final File newFunctionFile = new File("target/test/src/main/java/com/microsoft/azure/New_Function.java");
    newFunctionFile.delete();

    mojo.doExecute();

    assertTrue(newFunctionFile.exists());
}
 

import org.apache.maven.settings.Settings; //导入依赖的package包/类
public static Settings loadMavenSettings()
    throws SettingsBuildingException {
  // http://stackoverflow.com/questions/27818659/loading-mavens-settings-xml-for-jcabi-aether-to-use
  SettingsBuildingRequest settingsBuildingRequest =
      new DefaultSettingsBuildingRequest();
  settingsBuildingRequest.setSystemProperties(System.getProperties());
  settingsBuildingRequest.setUserSettingsFile(new File(settingsXml));
  settingsBuildingRequest.setGlobalSettingsFile(DEFAULT_GLOBAL_SETTINGS_FILE);

  SettingsBuildingResult settingsBuildingResult;
  DefaultSettingsBuilderFactory mvnSettingBuilderFactory =
      new DefaultSettingsBuilderFactory();
  DefaultSettingsBuilder settingsBuilder =
      mvnSettingBuilderFactory.newInstance();
  settingsBuildingResult = settingsBuilder.build(settingsBuildingRequest);

  Settings effectiveSettings = settingsBuildingResult.getEffectiveSettings();
  return effectiveSettings;
}
 

import org.apache.maven.settings.Settings; //导入依赖的package包/类
private static final Settings getSettings() throws SettingsBuildingException {
  final SettingsBuilder settingsBuilder = new DefaultSettingsBuilderFactory().newInstance(); // this method should be static!
  assert settingsBuilder != null;
  final DefaultSettingsBuildingRequest settingsBuildingRequest = new DefaultSettingsBuildingRequest();
  settingsBuildingRequest.setSystemProperties(System.getProperties());
  // settingsBuildingRequest.setUserProperties(userProperties); // TODO: implement this
  settingsBuildingRequest.setGlobalSettingsFile(new File("/usr/local/maven/conf/settings.xml")); // TODO: do this for real
  settingsBuildingRequest.setUserSettingsFile(new File(new File(System.getProperty("user.home")), ".m2/settings.xml"));
  final SettingsBuildingResult settingsBuildingResult = settingsBuilder.build(settingsBuildingRequest);
  assert settingsBuildingResult != null;
  final List<SettingsProblem> settingsBuildingProblems = settingsBuildingResult.getProblems();
  if (settingsBuildingProblems != null && !settingsBuildingProblems.isEmpty()) {
    throw new SettingsBuildingException(settingsBuildingProblems);
  }
  return settingsBuildingResult.getEffectiveSettings();
}
 

import org.apache.maven.settings.Settings; //导入依赖的package包/类
@Before
public void setUp() {
  logOutput = mock(LogOutput.class);
  runtimeInformation = mock(RuntimeInformation.class, Mockito.RETURNS_DEEP_STUBS);
  mavenSession = mock(MavenSession.class);
  rootProject = mock(MavenProject.class);
  mojoExecution = mock(MojoExecution.class);
  envProps = new Properties();

  Properties system = new Properties();
  system.put("system", "value");
  system.put("user", "value");
  Properties root = new Properties();
  root.put("root", "value");
  envProps.put("env", "value");

  when(mojoExecution.getVersion()).thenReturn("2.0");
  when(runtimeInformation.getMavenVersion()).thenReturn("1.0");
  when(mavenSession.getSystemProperties()).thenReturn(system);
  when(mavenSession.getUserProperties()).thenReturn(new Properties());
  when(mavenSession.getSettings()).thenReturn(new Settings());
  when(rootProject.getProperties()).thenReturn(root);
  when(mavenSession.getCurrentProject()).thenReturn(rootProject);
  propertyDecryptor = new PropertyDecryptor(mock(Log.class), mock(SecDispatcher.class));
}
 

import org.apache.maven.settings.Settings; //导入依赖的package包/类
private List<Profile> determineActiveProfiles(Settings settings) {
	SpringBootCliModelProblemCollector problemCollector = new SpringBootCliModelProblemCollector();
	List<org.apache.maven.model.Profile> activeModelProfiles = createProfileSelector()
			.getActiveProfiles(createModelProfiles(settings.getProfiles()),
					new SpringBootCliProfileActivationContext(
							settings.getActiveProfiles()),
					problemCollector);
	if (!problemCollector.getProblems().isEmpty()) {
		throw new IllegalStateException(createFailureMessage(problemCollector));
	}
	List<Profile> activeProfiles = new ArrayList<Profile>();
	Map<String, Profile> profiles = settings.getProfilesAsMap();
	for (org.apache.maven.model.Profile modelProfile : activeModelProfiles) {
		activeProfiles.add(profiles.get(modelProfile.getId()));
	}
	return activeProfiles;
}
 

import org.apache.maven.settings.Settings; //导入依赖的package包/类
static AwsKeyPair getAwsKeyPair(String serverId, String awsAccessKey, String awsSecretAccessKey,
        Settings settings, SettingsDecrypter decrypter) throws MojoExecutionException {
    final AwsKeyPair keys;
    if (serverId != null) {
        Server server = settings.getServer(serverId);
        if (server == null) {
            throw new MojoExecutionException("serverId not found in settings: " + serverId);
        } else {
            SettingsDecryptionRequest request = new DefaultSettingsDecryptionRequest(server);
            SettingsDecryptionResult result = decrypter.decrypt(request);
            keys = new AwsKeyPair(result.getServer().getUsername(),
                    result.getServer().getPassword());
        }
    } else {
        keys = new AwsKeyPair(awsAccessKey, awsSecretAccessKey);
    }
    return keys;
}
 

import org.apache.maven.settings.Settings; //导入依赖的package包/类
private Settings loadSettings() {
	File settingsFile = new File(this.homeDir, ".m2/settings.xml");
	if (settingsFile.exists()) {
		log.info("Reading settings from: " + settingsFile);
	}
	else {
		log.info("No settings found at: " + settingsFile);
	}
	SettingsBuildingRequest request = new DefaultSettingsBuildingRequest();
	request.setUserSettingsFile(settingsFile);
	request.setSystemProperties(System.getProperties());
	try {
		return new DefaultSettingsBuilderFactory().newInstance().build(request)
				.getEffectiveSettings();
	}
	catch (SettingsBuildingException ex) {
		throw new IllegalStateException(
				"Failed to build settings from " + settingsFile, ex);
	}
}
 

import org.apache.maven.settings.Settings; //导入依赖的package包/类
@SuppressWarnings("unchecked") // because of Maven poor typing
public String getPropertyValueInSettings(String propertyName, Settings settings) {
	if (settings == null) {
		return null;
	}

	List<String> activeProfiles = settings.getActiveProfiles();

	for (Object _profileWithId : settings.getProfilesAsMap().entrySet()) {
		Entry<String, Profile> profileWithId = (Entry<String, Profile>) _profileWithId;
		if (activeProfiles.contains(profileWithId.getKey())) {
			Profile profile = profileWithId.getValue();

			String value = profile.getProperties().getProperty(propertyName);
			if (value != null) {
				return value;
			}
		}
	}

	return null;
}
 

import org.apache.maven.settings.Settings; //导入依赖的package包/类
@SuppressWarnings("unchecked") // because of Maven poor typing
public boolean propertyExistsInSettings(String propertyName, Settings settings) {
	if (settings == null) {
		return false;
	}

	List<String> activeProfiles = getActiveProfiles(settings);

	for (Object _profileWithId : settings.getProfilesAsMap().entrySet()) {
		Entry<String, Profile> profileWithId = (Entry<String, Profile>) _profileWithId;
		if (activeProfiles.contains(profileWithId.getKey())) {
			Profile profile = profileWithId.getValue();

			boolean result = profile.getProperties().containsKey(propertyName);
			if (result) {
				return result;
			}
		}
	}

	return false;
}
 

import org.apache.maven.settings.Settings; //导入依赖的package包/类
public void test002DefaultUsernamePassword()
    throws MojoExecutionException
{

    Settings settings = new Settings();
    Server server = new Server();
    settings.addServer( server );

    mojo.setSettings( settings );

    // force a lookup of username
    mojo.setUsername( null );
    mojo.setPassword( null );

    mojo.execute();

    assertEquals( "", mojo.getUsername() );
    assertEquals( "", mojo.getPassword() );

}
 

import org.apache.maven.settings.Settings; //导入依赖的package包/类
public void test003UsernamePasswordLookup()
    throws MojoExecutionException
{

    Settings settings = new Settings();
    Server server = new Server();
    server.setId( "somekey" );
    server.setUsername( "username" );
    server.setPassword( "password" );
    settings.addServer( server );

    mojo.setSettings( settings );

    // force a lookup of username
    mojo.setSettingsKey( "somekey" );
    mojo.setUsername( null );
    mojo.setPassword( null );

    mojo.execute();

    assertEquals( "username", mojo.getUsername() );
    assertEquals( "password", mojo.getPassword() );

}
 

import org.apache.maven.settings.Settings; //导入依赖的package包/类
private static RuleSet loadRuleSet( String serverId, Settings settings, WagonManager wagonManager, String rulesUri,
                                    Log logger )
    throws MojoExecutionException {
    RuleSet ruleSet = new RuleSet();
    boolean rulesUriGiven = isRulesUriNotBlank(rulesUri);

    if (rulesUriGiven) {
        RuleSet loadedRules;

        if (isClasspathUri(rulesUri)) {
            loadedRules = getRulesFromClasspath(rulesUri, logger);
        } else {
            loadedRules = getRulesViaWagon(rulesUri, logger, serverId, serverId, wagonManager,
                                                   settings);
        }

        ruleSet.setIgnoreVersions(loadedRules.getIgnoreVersions());
        ruleSet.setRules(loadedRules.getRules());
    }

    return ruleSet;
}
 

import org.apache.maven.settings.Settings; //导入依赖的package包/类
private DefaultVersionsHelper createHelper( String rulesUri, ArtifactMetadataSource metadataSource )
    throws MojoExecutionException
{
    final DefaultWagonManager wagonManager = new DefaultWagonManager()
    {
        public Wagon getWagon( Repository repository )
            throws UnsupportedProtocolException, WagonConfigurationException
        {
            return new FileWagon();
        }
    };

    DefaultVersionsHelper helper =
        new DefaultVersionsHelper( new DefaultArtifactFactory(), new DefaultArtifactResolver(), metadataSource, new ArrayList(),
                                   new ArrayList(),
                                   new DefaultArtifactRepository( "", "", new DefaultRepositoryLayout() ),
                                   wagonManager, new Settings(), "", rulesUri, mock( Log.class ), mock( MavenSession.class ),
                                   new DefaultPathTranslator());
    return helper;
}
 

import org.apache.maven.settings.Settings; //导入依赖的package包/类
@Test
public void testGetActiveHttpProxy()
    throws IOException, XmlPullParserException
{
    SettingsXpp3Reader r = new SettingsXpp3Reader();
    Settings s = r.read( WsImportMojoTest.class.getResourceAsStream( "proxy1.xml" ) );
    String proxyString = WsImportMojo.getActiveHttpProxy( s );
    Assert.assertEquals( proxyString, "proxyActive:8099" );

    s = r.read( WsImportMojoTest.class.getResourceAsStream( "proxy2.xml" ) );
    proxyString = WsImportMojo.getActiveHttpProxy( s );
    Assert.assertNull( proxyString, proxyString );

    s = r.read( WsImportMojoTest.class.getResourceAsStream( "proxy3.xml" ) );
    proxyString = WsImportMojo.getActiveHttpProxy( s );
    Assert.assertEquals( proxyString, "proxyuser:[email protected]:8080" );

    s = r.read( WsImportMojoTest.class.getResourceAsStream( "proxy4.xml" ) );
    proxyString = WsImportMojo.getActiveHttpProxy( s );
    Assert.assertEquals( proxyString, "[email protected]:7777" );
}
 

import org.apache.maven.settings.Settings; //导入依赖的package包/类
/**
 * Recieves artifactories MavenSettings object and transforms it to maven's Settings object
 *
 * @param mavenSettings Settings to transform
 * @return Settings - Transformed settings
 */
private Settings transformSettings(MavenSettings mavenSettings) {
    String contextUrl = mavenSettings.getUrl();

    Settings settings = new Settings();

    Profile profile = new Profile();
    profile.setId("artifactory");

    //Add plugin and releases repositories to the profile
    addReleaseRepositories(contextUrl, profile, mavenSettings.getReleaseRepositories());
    addPluginRepositories(contextUrl, profile, mavenSettings.getPluginRepositories());
    settings.addProfile(profile);
    settings.setActiveProfiles(Collections.singletonList(profile.getId()));

    //Add mirrors to the settings
    addMirrors(contextUrl, settings, mavenSettings.getMirrorRepositories());

    addServers(settings, mavenSettings.getServers());

    return settings;
}
 

import org.apache.maven.settings.Settings; //导入依赖的package包/类
/**
 * Adds a list of server configurations to the maven settings object
 *
 * @param settings Maven Settings to append to
 * @param servers  Servers to add to the settings
 */
private void addServers(Settings settings, List<MavenSettingsServer> servers) {
    for (MavenSettingsServer server : servers) {
        Server serverToAdd = new Server();
        serverToAdd.setId(server.getId());

        String username = server.getUsername();
        String password = server.getPassword();

        if (StringUtils.isNotBlank(username)) {
            serverToAdd.setUsername(username);
        }
        if (StringUtils.isNotBlank(password)) {
            serverToAdd.setPassword(password);
        }
        settings.addServer(serverToAdd);
    }
}