public async Task <IEnumerable <string> > GetSuggestionsAsync(IComponentConfiguration config)
{
var credentialName = config["CredentialName"];
if (string.IsNullOrEmpty(credentialName))
{
return(Enumerable.Empty <string>());
}
var credentials = ResourceCredentials.Create <GitHubCredentials>(credentialName);
string ownerName = AH.CoalesceString(credentials.OrganizationName, credentials.UserName);
string repositoryName = AH.CoalesceString(config["RepositoryName"], credentials.RepositoryName);
if (string.IsNullOrEmpty(ownerName) || string.IsNullOrEmpty(repositoryName))
{
return(Enumerable.Empty <string>());
}
var client = new GitHubClient(credentials.ApiUrl, credentials.UserName, credentials.Password, credentials.OrganizationName);
var milestones = await client.GetMilestonesAsync(ownerName, repositoryName, "open").ConfigureAwait(false);
var titles = from m in milestones
let title = m["title"]?.ToString()
where !string.IsNullOrEmpty(title)
select title;
return(new[] { "$ReleaseName", "$ReleaseNumber" }.Concat(titles));
}
public override async Task <PromotionRequirementStatus> GetStatusAsync(PromotionContext context)
{
var entity = InfrastructureEntity.Create(serverName: this.Server, roleName: this.Role);
if (entity == null)
{
return(new PromotionRequirementStatus(PromotionRequirementState.NotApplicable, "A server or role must be specified to determine drift status."));
}
var credentials = ResourceCredentials.Create <InedoProductCredentials>(this.CredentialName);
var client = OtterClient.Create(credentials.Host, credentials.ApiKey);
try
{
await client.TriggerConfigurationCheckAsync(entity).ConfigureAwait(false);
await Task.Delay(2 * 1000).ConfigureAwait(false);
var config = await client.GetConfigurationStatusAsync(entity).ConfigureAwait(false);
if (string.Equals(config.Status, this.Status.ToString(), StringComparison.OrdinalIgnoreCase))
{
return(new PromotionRequirementStatus(PromotionRequirementState.Met, $"{entity} status is {config.Status}."));
}
else
{
return(new PromotionRequirementStatus(PromotionRequirementState.NotMet, $"{entity} status is {config.Status}, must be {this.Status.ToString().ToLowerInvariant()}."));
}
}
catch (OtterException ex)
{
return(new PromotionRequirementStatus(PromotionRequirementState.NotMet, ex.FullMessage));
}
}
public async Task <IEnumerable <string> > GetSuggestionsAsync(IComponentConfiguration config)
{
var credentialName = config["CredentialName"];
var feedName = config["FeedName"];
if (string.IsNullOrEmpty(credentialName) || string.IsNullOrEmpty(feedName))
{
return(Enumerable.Empty <string>());
}
ProGetClient client = null;
var productCredentials = ResourceCredentials.TryCreate <InedoProductCredentials>(credentialName);
if (productCredentials != null)
{
client = new ProGetClient(productCredentials.Host, feedName, "api", AH.Unprotect(productCredentials.ApiKey));
}
if (client == null)
{
#pragma warning disable CS0618 // Type or member is obsolete
var credentials = ResourceCredentials.Create <ProGetCredentials>(credentialName);
#pragma warning restore CS0618 // Type or member is obsolete
client = new ProGetClient(credentials.Url, feedName, credentials.UserName, AH.Unprotect(credentials.Password));
}
var packages = await client.GetPackagesAsync().ConfigureAwait(false);
return(from p in packages
let name = new PackageName(p.@group, p.name)
orderby name.Group, name.Name
select name.ToString());
}
public async Task <IEnumerable <string> > GetSuggestionsAsync(IComponentConfiguration config)
{
var credentialName = config["CredentialName"];
if (string.IsNullOrEmpty(credentialName))
{
return(Enumerable.Empty <string>());
}
var credentials = ResourceCredentials.Create <GitHubCredentials>(credentialName);
string ownerName = AH.CoalesceString(credentials.OrganizationName, credentials.UserName);
if (string.IsNullOrEmpty(ownerName))
{
return(Enumerable.Empty <string>());
}
var client = new GitHubClient(credentials.ApiUrl, credentials.UserName, credentials.Password, credentials.OrganizationName);
var repos = await client.GetRepositoriesAsync().ConfigureAwait(false);
var names = from m in repos
let name = m["name"]?.ToString()
where !string.IsNullOrEmpty(name)
select name;
return(new[] { "$ApplicationName" }.Concat(names));
}
public async Task <IEnumerable <string> > GetSuggestionsAsync(IComponentConfiguration config)
{
var credentialName = config[nameof(IHasCredentials.CredentialName)];
if (string.IsNullOrEmpty(credentialName))
{
return(Enumerable.Empty <string>());
}
var credentials = ResourceCredentials.Create <GitHubCredentials>(credentialName);
string ownerName = AH.CoalesceString(credentials.OrganizationName, credentials.UserName);
if (string.IsNullOrEmpty(ownerName))
{
return(Enumerable.Empty <string>());
}
var client = new GitHubClient(credentials.ApiUrl, credentials.UserName, credentials.Password, credentials.OrganizationName);
var orgs = await client.GetOrganizationsAsync(CancellationToken.None).ConfigureAwait(false);
var names = from m in orgs
let name = m["login"]?.ToString()
where !string.IsNullOrEmpty(name)
select name;
return(names);
}
public async Task <IEnumerable <string> > GetSuggestionsAsync(IComponentConfiguration config)
{
var credentialName = config["CredentialName"];
if (string.IsNullOrEmpty(credentialName))
{
return(Enumerable.Empty <string>());
}
var credentials = ResourceCredentials.Create <GitLabCredentials>(credentialName);
string ownerName = AH.CoalesceString(credentials.GroupName, credentials.UserName);
string repositoryName = AH.CoalesceString(config["ProjectName"], credentials.ProjectName);
if (string.IsNullOrEmpty(ownerName) || string.IsNullOrEmpty(repositoryName))
{
return(Enumerable.Empty <string>());
}
var client = new GitLabClient(credentials.ApiUrl, credentials.UserName, credentials.Password, credentials.GroupName);
var milestones = await client.GetMilestonesAsync(repositoryName, "open", CancellationToken.None).ConfigureAwait(false);
var titles = from m in milestones
let title = m["title"]?.ToString()
where !string.IsNullOrEmpty(title)
select title;
if (SDK.ProductName == "BuildMaster")
{
titles = new[] { "$ReleaseName", "$ReleaseNumber" }.Concat(titles);
}
return(titles);
}
public async Task <IEnumerable <string> > GetSuggestionsAsync(IComponentConfiguration config)
{
var credentialName = config["CredentialName"];
var projectName = AH.CoalesceString(config["TeamProject"], config["TeamProjectName"]);
var definitionName = config["BuildDefinition"];
if (string.IsNullOrEmpty(credentialName) || string.IsNullOrEmpty(projectName) || string.IsNullOrEmpty(definitionName))
{
return(Enumerable.Empty <string>());
}
var credentials = ResourceCredentials.Create <TfsCredentials>(credentialName);
var api = new TfsRestApi(credentials, null);
var definition = await api.GetBuildDefinitionAsync(projectName, definitionName).ConfigureAwait(false);
if (definition == null)
{
return(Enumerable.Empty <string>());
}
var builds = await api.GetBuildsAsync(projectName, definition.id).ConfigureAwait(false);
return(builds.Select(b => b.buildNumber));
}
public async Task <IEnumerable <string> > GetSuggestionsAsync(IComponentConfiguration config)
{
var credentialName = config["CredentialName"];
var feedName = config["FeedName"];
var packageName = config["PackageName"];
if (string.IsNullOrEmpty(credentialName) || string.IsNullOrEmpty(feedName) || string.IsNullOrEmpty(packageName))
{
return(Enumerable.Empty <string>());
}
ProGetClient client = null;
var productCredentials = ResourceCredentials.TryCreate <InedoProductCredentials>(credentialName);
if (productCredentials != null)
{
client = new ProGetClient(productCredentials.Host, feedName, "api", AH.Unprotect(productCredentials.ApiKey));
}
#pragma warning disable CS0618 // Type or member is obsolete
var credentials = ResourceCredentials.Create <ProGetCredentials>(credentialName);
#pragma warning restore CS0618 // Type or member is obsolete
if (client == null)
{
client = new ProGetClient(credentials.Url, feedName, credentials.UserName, AH.Unprotect(credentials.Password));
}
var package = await client.GetPackageInfoAsync(PackageName.Parse(packageName));
return(new[] { "latest", "latest-stable" }.Concat(package.versions));
}
public async Task <IEnumerable <string> > GetSuggestionsAsync(IComponentConfiguration config)
{
var credentialName = config["CredentialName"];
if (string.IsNullOrEmpty(credentialName))
{
return(Enumerable.Empty <string>());
}
var projectName = config["ProjectName"];
if (string.IsNullOrEmpty(projectName))
{
return(Enumerable.Empty <string>());
}
var buildConfigurationName = config["BuildConfigurationName"];
if (string.IsNullOrEmpty(projectName))
{
return(Enumerable.Empty <string>());
}
var credentials = ResourceCredentials.Create <TeamCityCredentials>(credentialName);
using (var client = new TeamCityWebClient(credentials))
{
return(await client.GetBuildNumbersAsync(projectName, buildConfigurationName).ConfigureAwait(false));
}
}
internal static GitLabCredentials TryCreate(string name, IOperationConfiguration config)
{
int?projectId = AH.ParseInt(AH.CoalesceString(config["ProjectId"], config["ApplicationId"]));
int?environmentId = AH.ParseInt(config["EnvironmentId"]);
return((GitLabCredentials)ResourceCredentials.TryCreate(GitLabCredentials.TypeName, name, environmentId: environmentId, applicationId: projectId, inheritFromParent: false));
}
public async Task <IEnumerable <string> > GetSuggestionsAsync(IComponentConfiguration config)
{
var credentialName = config["CredentialName"];
var jobName = config["JobName"];
if (string.IsNullOrEmpty(credentialName) || string.IsNullOrEmpty(jobName))
{
return(Enumerable.Empty <string>());
}
var branchName = config["BranchName"];
string buildNumber = AH.CoalesceString(config["BuildNumber"], "lastSuccessfulBuild");
int?projectId = AH.ParseInt(AH.CoalesceString(config["ProjectId"], config["ApplicationId"]));
int?environmentId = AH.ParseInt(config["EnvironmentId"]);
var credentials = (JenkinsLegacyCredentials)ResourceCredentials.TryCreate(JenkinsLegacyCredentials.TypeName, credentialName, environmentId: environmentId, applicationId: projectId, inheritFromParent: false);
if (credentials == null)
{
return(Enumerable.Empty <string>());
}
using (var cts = new CancellationTokenSource(new TimeSpan(0, 0, 30)))
{
var client = new JenkinsClient(credentials.UserName, credentials.Password, credentials.ServerUrl, false, null, cts.Token);
return((await client.GetBuildArtifactsAsync(jobName, branchName, buildNumber))
.Select(a => a.RelativePath)
.ToList());
}
}
public async Task <IEnumerable <string> > GetSuggestionsAsync(IComponentConfiguration config)
{
var credentialName = config["CredentialName"];
if (string.IsNullOrEmpty(credentialName))
{
return(Enumerable.Empty <string>());
}
var productCredentials = ResourceCredentials.TryCreate <InedoProductCredentials>(credentialName);
if (productCredentials != null)
{
var url = new Uri(productCredentials.Host, UriKind.Absolute).GetLeftPart(UriPartial.Authority);
var c = new ProGetClient(url, null, "api", AH.Unprotect(productCredentials.ApiKey));
return(await c.GetFeedNamesAsync().ConfigureAwait(false));
}
#pragma warning disable CS0618 // Type or member is obsolete
var credentials = ResourceCredentials.Create <ProGetCredentials>(credentialName);
#pragma warning restore CS0618 // Type or member is obsolete
string baseUrl = new Uri(credentials.Url, UriKind.Absolute).GetLeftPart(UriPartial.Authority);
var client = new ProGetClient(baseUrl, null, credentials.UserName, AH.Unprotect(credentials.Password));
return(await client.GetFeedNamesAsync().ConfigureAwait(false));
}
public async Task <IEnumerable <string> > GetSuggestionsAsync(IComponentConfiguration config)
{
var credentialName = config["CredentialName"];
if (string.IsNullOrEmpty(credentialName))
{
return(Enumerable.Empty <string>());
}
var credentials = ResourceCredentials.Create <GitLabCredentials>(credentialName);
string ownerName = AH.CoalesceString(credentials.GroupName, credentials.UserName);
if (string.IsNullOrEmpty(ownerName))
{
return(Enumerable.Empty <string>());
}
var client = new GitLabClient(credentials.ApiUrl, credentials.UserName, credentials.Password, credentials.GroupName);
var repos = await client.GetProjectsAsync(CancellationToken.None).ConfigureAwait(false);
var names = from m in repos
let name = m["path_with_namespace"]?.ToString()
where !string.IsNullOrEmpty(name)
select name;
if (SDK.ProductName == "BuildMaster")
{
names = new[] { $"{ownerName}/$ApplicationName" }.Concat(names);
}
return(names);
}
public async Task <IEnumerable <string> > GetSuggestionsAsync(IComponentConfiguration config)
{
var credentialName = config["CredentialName"];
var jobName = config["JobName"];
if (string.IsNullOrEmpty(credentialName) || string.IsNullOrEmpty(jobName))
{
return(Enumerable.Empty <string>());
}
var branchName = config["BranchName"];
int?projectId = AH.ParseInt(AH.CoalesceString(config["ProjectId"], config["ApplicationId"]));
int?environmentId = AH.ParseInt(config["EnvironmentId"]);
var credentials = (JenkinsLegacyCredentials)ResourceCredentials.TryCreate(JenkinsLegacyCredentials.TypeName, credentialName, environmentId: environmentId, applicationId: projectId, inheritFromParent: false);
if (credentials == null)
{
return(Enumerable.Empty <string>());
}
using (var cts = new CancellationTokenSource(new TimeSpan(0, 0, 30)))
{
var client = this.CreateClient(config, cts.Token);
return(await client.GetBuildNumbersAsync(jobName, branchName).ConfigureAwait(false));
}
}
public override async Task <IEnumerable <string> > EnumerateValuesAsync(ValueEnumerationContext context)
{
var credentials = ResourceCredentials.Create <JenkinsCredentials>(this.CredentialName);
var client = new JenkinsClient(credentials);
return(await client.GetBuildNumbersAsync(this.JobName).ConfigureAwait(false));
}
public void PublishEventsToTopic()
{
using (MockContext context = MockContext.Start(this.GetType().FullName))
{
this.InitializeClients(context);
var location = this.ResourceManagementClient.GetLocationFromProvider();
var resourceGroup = this.ResourceManagementClient.TryGetResourceGroup(location);
if (string.IsNullOrWhiteSpace(resourceGroup))
{
resourceGroup = TestUtilities.GenerateName(EventGridManagementHelper.ResourceGroupPrefix);
this.ResourceManagementClient.TryRegisterResourceGroup(location, resourceGroup);
}
var topicName = TestUtilities.GenerateName(EventGridManagementHelper.TopicPrefix);
var originalTagsDictionary = new Dictionary <string, string>()
{
{ "originalTag1", "originalValue1" },
{ "originalTag2", "originalValue2" }
};
Topic topic = new Topic()
{
Location = location,
Tags = originalTagsDictionary
};
var createTopicResponse = this.EventGridManagementClient.Topics.CreateOrUpdate(resourceGroup, topicName, topic);
Assert.NotNull(createTopicResponse);
Assert.Equal(createTopicResponse.Name, topicName);
TestUtilities.Wait(TimeSpan.FromSeconds(60));
// Get the topic key
TopicSharedAccessKeys keys = this.EventGridManagementClient.Topics.ListSharedAccessKeys(resourceGroup, topicName);
// Publish events to topic
string topicHostname = new Uri(createTopicResponse.Endpoint).Host;
ResourceCredentials credentials = new ResourceCredentials(keys.Key1);
EventGridClient client = EventGridManagementHelper.GetEventGridClient(
context,
credentials,
new RecordedDelegatingHandler {
StatusCodeToReturn = HttpStatusCode.OK
});
Console.WriteLine("Publishing to Azure Event Grid Topic");
client.PublishEventsAsync(topicHostname, GetEventsList()).GetAwaiter().GetResult();
Console.WriteLine("Published successfully!");
// Delete topic
this.EventGridManagementClient.Topics.Delete(resourceGroup, topicName);
}
}
public override async Task <IEnumerable <string> > EnumerateValuesAsync(ValueEnumerationContext context)
{
var credentials = ResourceCredentials.Create <TfsCredentials>(this.CredentialName);
var api = new TfsRestApi(credentials, null);
var definitions = await api.GetBuildDefinitionsAsync(this.TeamProjectName).ConfigureAwait(false);
return(definitions.Select(d => d.name));
}
public override async Task <IEnumerable <string> > EnumerateValuesAsync(ValueEnumerationContext context)
{
var credentials = ResourceCredentials.Create <TeamCityCredentials>(this.CredentialName);
using (var client = new TeamCityWebClient(credentials))
{
return(await client.GetBuildNumbersAsync(this.ProjectName, this.BuildConfigurationName).ConfigureAwait(false));
}
}
public override async Task <IEnumerable <string> > EnumerateValuesAsync(ValueEnumerationContext context)
{
var credentials = ResourceCredentials.Create <TfsCredentials>(this.CredentialName);
var api = new TfsRestApi(credentials, null);
var projects = await api.GetProjectsAsync().ConfigureAwait(false);
return(projects.Select(p => p.name));
}
private TfsCredentials GetCredentials()
{
string credentialName = this.config["CredentialName"];
if (string.IsNullOrEmpty(credentialName))
{
return(null);
}
return(ResourceCredentials.Create <TfsCredentials>(credentialName));
}
public Task <IEnumerable <string> > GetSuggestionsAsync(IComponentConfiguration config)
{
var credentials = ResourceCredentials.Create <ArtifactoryCredentials>(config[nameof(IHasCredentials <ArtifactoryCredentials> .CredentialName)]);
var baseUrl = AH.CoalesceString(config[nameof(ArtifactoryCredentials.BaseUrl)], credentials?.BaseUrl);
var userName = AH.CoalesceString(config[nameof(ArtifactoryCredentials.UserName)], credentials?.UserName);
var password = CoalescePassword(config[nameof(ArtifactoryCredentials.Password)], credentials?.Password);
return(GetSuggestionsAsync(new ArtifactoryCredentials {
BaseUrl = baseUrl, UserName = userName, Password = password
}, config));
}
private object GetCredentialPropertyValue(ResourceCredentials credentials)
{
var prop = credentials.GetType().GetProperty(this.MappedCredentialPropertyName);
if (prop == null)
{
return(null);
}
return(prop.GetValue(credentials));
}
public static EventGridClient GetEventGridClient(MockContext context, ResourceCredentials credentials, RecordedDelegatingHandler handler)
{
if (handler != null)
{
handler.IsPassThrough = true;
TestEnvironment testEnvironment = TestEnvironmentFactory.GetTestEnvironment();
EventGridClient eventGridClient = context.GetServiceClientWithCredentials <EventGridClient>(testEnvironment, credentials, true, handler);
return(eventGridClient);
}
return(null);
}
public override async Task <IEnumerable <string> > EnumerateListValuesAsync(VariableTemplateContext context)
{
var credentials = (JenkinsLegacyCredentials)ResourceCredentials.TryCreate(JenkinsLegacyCredentials.TypeName, this.CredentialName, environmentId: null, applicationId: context.ProjectId, inheritFromParent: false);
if (credentials == null)
{
return(Enumerable.Empty <string>());
}
var client = new JenkinsClient(credentials.UserName, credentials.Password, credentials.ServerUrl, true, null, default);
return(await client.GetBuildNumbersAsync(this.JobName, this.BranchName).ConfigureAwait(false));
}
protected YouTrackClient CreateClient(IComponentConfiguration config)
{
var credentials = ResourceCredentials.Create <YouTrackCredentials>(config[nameof(IHasCredentials <YouTrackCredentials> .CredentialName)]);
return(new YouTrackClient(
new YouTrackCredentials
{
ServerUrl = AH.CoalesceString(config[nameof(YouTrackOperationBase.ServerUrl)], credentials?.ServerUrl),
UserName = AH.CoalesceString(config[nameof(YouTrackOperationBase.UserName)], credentials?.UserName),
Password = AH.CreateSecureString(AH.CoalesceString(config[nameof(YouTrackOperationBase.Password)], AH.Unprotect(credentials?.Password))),
PermanentToken = AH.CreateSecureString(AH.CoalesceString(config[nameof(YouTrackOperationBase.PermanentToken)], AH.Unprotect(credentials?.PermanentToken))),
}
));
}
protected override object EvaluateScalar(IVariableFunctionContext context)
{
var name = Inedo.Extensibility.Credentials.CredentialName.TryParse(this.CredentialName);
if (name == null)
{
throw new ExecutionFailureException(true, $"The specified credential name \"{this.CredentialName}\" is invalid.");
}
// need to resolve credential type name if it's not specified with the scope resolution operator
if (name.TypeName == null)
{
var types = (from c in SDK.GetCredentials()
where string.Equals(c.Name, name.Name, StringComparison.OrdinalIgnoreCase)
select c.LegacyResourceCredentialTypeName).ToHashSet(StringComparer.OrdinalIgnoreCase);
if (types.Count == 0)
{
throw new ExecutionFailureException(true, $"There are no credentials named \"{name.Name}\" found in the system.");
}
if (types.Count > 1)
{
throw new ExecutionFailureException(true, $"There are multiple credential types with the name \"{name.Name}\" found in the system. Use the scope resolution operator (i.e. ::) to specify a type, for example: UsernamePassword::{name.Name}");
}
name = new CredentialName(types.First(), name.Name);
}
var credential = ResourceCredentials.TryCreate(name.TypeName, name.Name, environmentId: context.EnvironmentId, applicationId: context.ProjectId, inheritFromParent: true);
if (credential == null)
{
throw new ExecutionFailureException($"Could not find a {name.TypeName} Resource Credentials named \"{name.Name}\"; this error may occur if you renamed a credential, or the application or environment in context does not match any existing credentials. To resolve, edit this item, property, or operation's configuration, ensure a valid credential for the application/environment in context is selected, and then save.");
}
if (!(credential is JenkinsLegacyCredentials))
{
throw new ExecutionFailureException($"Resource Credential \"{name.Name}\" is not a Jenkins Credential.");
}
var jenkins = (JenkinsLegacyCredentials)credential;
UriBuilder uri = new UriBuilder(jenkins.ServerUrl)
{
Path = JenkinsClient.GetPath(this.JobName, this.BranchName, this.BuildNumber)
};
return(uri.ToString());
}
public async Task <IEnumerable <string> > GetSuggestionsAsync(IComponentConfiguration config)
{
var credentialName = config["CredentialName"];
if (string.IsNullOrEmpty(credentialName))
{
return(Enumerable.Empty <string>());
}
var credentials = ResourceCredentials.Create <ProGetCredentials>(credentialName);
string baseUrl = new Uri(credentials.Url, UriKind.Absolute).GetLeftPart(UriPartial.Authority);
var client = new ProGetClient(baseUrl, null, credentials.UserName, ConvertValue(credentials.Password));
return(await client.GetFeedNamesAsync().ConfigureAwait(false));
}
public async Task <IEnumerable <string> > GetSuggestionsAsync(IComponentConfiguration config)
{
var credentialName = config["CredentialName"];
if (string.IsNullOrEmpty(credentialName))
{
return(Enumerable.Empty <string>());
}
var credentials = ResourceCredentials.Create <JenkinsCredentials>(credentialName);
var client = new JenkinsClient(credentials);
var jobs = await client.GetJobNamesAsync().ConfigureAwait(false);
return(jobs);
}
public async Task <IEnumerable <string> > GetSuggestionsAsync(IComponentConfiguration config)
{
string credentialName = config["CredentialName"];
if (string.IsNullOrEmpty(credentialName))
{
return(Enumerable.Empty <string>());
}
var credentials = ResourceCredentials.Create <InedoProductCredentials>(credentialName);
var client = OtterClient.Create(credentials.Host, credentials.ApiKey);
var roles = await client.EnumerateInfrastructureAsync(InfrastructureEntity.Role).ConfigureAwait(false);
return(roles);
}
public async Task <IEnumerable <string> > GetSuggestionsAsync(IComponentConfiguration config)
{
string credentialName = config["CredentialName"];
if (string.IsNullOrEmpty(credentialName))
{
return(Enumerable.Empty <string>());
}
var credentials = ResourceCredentials.Create <OtterCredentials>(credentialName);
var client = new OtterClient(credentials.Host, credentials.ApiKey);
var servers = await client.EnumerateInfrastructureAsync(InfrastructureEntity.Environment).ConfigureAwait(false);
return(servers);
}
