static void Main(string[] args)
{
var addon = new Addon();
var manifest = new AddonManifest
{
Author = "Abraham Sultan",
Vendor = "Apprenda Inc.",
Version = "1.0.0.0",
IsEnabled = true,
Name = "AWS RDS",
Properties = new List <AddonProperty>()
{
new AddonProperty()
{
Key = "requireDevCredentials", Value = "true"
}
}
};
var request = new AddonTestRequest {
Manifest = manifest, DeveloperOptions = ""
};
addon.Test(request);
}
public override OperationResult Test(AddonTestRequest _request)
{
var manifest = _request.Manifest;
var devParameters = _request.DeveloperParameters;
var devOptions = BMDeveloperOptions.Parse(devParameters, manifest);
var testResult = new OperationResult {
EndUserMessage = string.Empty, IsSuccess = false
};
end_point = devOptions.api_url;
bm_version = devOptions.api_version;
try
{
var token = authenticate(devOptions.bluemixuser, devOptions.bluemixpass);
var servicePlansURL = getServicePlansURL(token, devOptions.servicename);
}
catch (Exception ex)
{
var errorMessage = string.Format("BluemixAddon Testing Error: {0}\n{1}", ex, ex.StackTrace);
log.Error(errorMessage);
testResult.EndUserMessage = errorMessage;
return(testResult);
}
testResult.EndUserMessage = "BluemixAddon Add-On was tested successfully";
testResult.IsSuccess = true;
return(testResult);
}
public static void TestManifestMissingDefaultCreds()
{
var addon = new Addon();
var manifest = GetAWSAddonManifest();
var result = new OperationResult();
var request = new AddonTestRequest {
Manifest = manifest, DeveloperOptions = ""
};
manifest.ProvisioningUsername = null;
manifest.ProvisioningPassword = "******";
result = addon.Test(request);
Assert.IsFalse(result.IsSuccess);
Assert.IsTrue(result.EndUserMessage.Contains("Missing credentials"), result.EndUserMessage);
manifest.ProvisioningUsername = "******";
manifest.ProvisioningPassword = null;
result = addon.Test(request);
Assert.IsFalse(result.IsSuccess);
Assert.IsTrue(result.EndUserMessage.Contains("Missing credentials"), result.EndUserMessage);
manifest.ProvisioningUsername = null;
manifest.ProvisioningPassword = null;
result = addon.Test(request);
Assert.IsFalse(result.IsSuccess);
Assert.IsTrue(result.EndUserMessage.Contains("Missing credentials"), result.EndUserMessage);
}
public override OperationResult Test(AddonTestRequest request)
{
return(Task.Run(async() =>
{
try
{
var logic = new Logic(request.Manifest);
var volumeSize = request.DeveloperParameters.First(p => p.Key == "VolumeSize").Value;
var name = Guid.NewGuid().ToString();
// Provision
await logic.ProvisionVolume(name, volumeSize);
// Deprovision
await logic.DeprovisionVolume(name);
return new OperationResult {
IsSuccess = true
};
}
catch (Exception ex)
{
return new OperationResult {
EndUserMessage = $"Error testing the add-on: {ex}"
};
}
}).GetAwaiter().GetResult());
}
public static void TestManifestMissingProperties()
{
var addon = new Addon();
var manifest = GetAWSAddonManifest();
manifest.Properties.Clear();
var request = new AddonTestRequest {
Manifest = manifest, DeveloperOptions = ""
};
var result = addon.Test(request);
Assert.IsFalse(result.IsSuccess);
Assert.IsTrue(result.EndUserMessage.Contains("Missing required manifest properties"), result.EndUserMessage);
manifest = GetAWSAddonManifest();
manifest.ProvisioningUsername = null;
manifest.ProvisioningPassword = "******";
request.Manifest = manifest;
result = addon.Test(request);
Assert.IsFalse(result.IsSuccess);
Assert.IsTrue(result.EndUserMessage.Contains("needs to be provided as part of the manifest"), result.EndUserMessage);
manifest = GetAWSAddonManifest();
manifest.ProvisioningUsername = "******";
manifest.ProvisioningPassword = null;
request.Manifest = manifest;
result = addon.Test(request);
Assert.IsFalse(result.IsSuccess);
Assert.IsTrue(result.EndUserMessage.Contains("needs to be provided as part of the manifest"), result.EndUserMessage);
}
public static void TestInvalidDevOptions()
{
var addon = new Addon();
var manifest = GetAWSAddonManifest();
var request = new AddonTestRequest {
Manifest = manifest
};
request.DeveloperOptions = "=&=";
var result = addon.Test(request);
Assert.IsFalse(result.IsSuccess);
Assert.IsTrue(result.EndUserMessage.Contains("Unable to parse developer options"), result.EndUserMessage);
request.DeveloperOptions = "random=key&";
result = addon.Test(request);
Assert.IsFalse(result.IsSuccess);
Assert.IsTrue(result.EndUserMessage.Contains("was not expected and is not understood"), result.EndUserMessage);
request.DeveloperOptions = "allocatedstorage=five";
result = addon.Test(request);
Assert.IsFalse(result.IsSuccess);
Assert.IsTrue(result.EndUserMessage.Contains("can only have an integer value"), result.EndUserMessage);
request.DeveloperOptions = "autominorversionupgrade=1";
result = addon.Test(request);
Assert.IsFalse(result.IsSuccess);
Assert.IsTrue(result.EndUserMessage.Contains("only have a value of true|false"), result.EndUserMessage);
}
public override OperationResult Test(AddonTestRequest _request)
{
// NOTE: Any exceptions thrown out of any add-on method will result in a failure of the operation.
// The full-depth exception from inside the add-on will get logged in the SOC, but if you
// wish to display a more user-friendly message in the report card format then you need to
// handle exceptions manually inside the add-on implementation.
var result = new OperationResult()
{
IsSuccess = false
};
string port;
try
{
port = _request.Manifest.Properties.Find(_x => _x.Key.Equals("port")).Value;
}
catch (ArgumentNullException)
{
port = "27017";
}
try
{
var parameters = DeveloperParameters.Parse(_request.DeveloperParameters, _request.Manifest.Properties);
var connectionString = GetConnectionString(_request.Manifest.ProvisioningLocation,
port,
_request.Manifest.ProvisioningUsername,
_request.Manifest.ProvisioningPassword);
var client = new MongoClient(connectionString);
// Create a DB and add a collection to make sure the MongoDB instance is configured correctly.
var database = client.GetDatabase("test");
//create user
var document = CreateUserAdd(parameters.Username, parameters.Password, "test");
database.RunCommand <BsonDocument>(document);
//create collection
var collection = database.GetCollection <TestObject>("testObjects");
collection.InsertOne(new TestObject {
Value = "test"
});
//delete user
DropUser(parameters.Username);
//delete database
client.DropDatabase("test");
result.IsSuccess = true;
}
catch (MongoException mongoException)
{
Logger.ErrorFormat("Error occurred during testing: {0} \n {1}", mongoException.Message, mongoException.StackTrace);
result.EndUserMessage = mongoException.Message;
}
catch (Exception mongoException)
{
Logger.ErrorFormat("Error occurred during testing: {0} \n {1}", mongoException.Message, mongoException.StackTrace);
result.EndUserMessage = mongoException.Message;
}
return(result);
}
// Testing Instance
// Input: AddonTestRequest request
// Output: OperationResult
public override OperationResult Test(AddonTestRequest request)
{
var testResult = new OperationResult {IsSuccess = false};
var apr = new AddonProvisionRequest
{
DeveloperParameters = request.DeveloperParameters,
Manifest = request.Manifest
};
var dpr = new AddonDeprovisionRequest
{
DeveloperParameters = request.DeveloperParameters,
Manifest = request.Manifest
};
var provisionTest = Provision(apr);
if (!provisionTest.IsSuccess)
{
return provisionTest;
}
var testProgress = provisionTest.EndUserMessage;
var deprovisionTest = Deprovision(dpr);
if (!deprovisionTest.IsSuccess)
{
return deprovisionTest;
}
testProgress += deprovisionTest.EndUserMessage;
testResult.IsSuccess = true;
testResult.EndUserMessage = testProgress;
return testResult;
}
// Testing Instance
// Input: AddonTestRequest request
// Output: OperationResult
public override OperationResult Test(AddonTestRequest request)
{
var testResult = new OperationResult {
IsSuccess = false
};
var apr = new AddonProvisionRequest
{
DeveloperParameters = request.DeveloperParameters,
Manifest = request.Manifest
};
var dpr = new AddonDeprovisionRequest
{
DeveloperParameters = request.DeveloperParameters,
Manifest = request.Manifest
};
var provisionTest = Provision(apr);
if (!provisionTest.IsSuccess)
{
return(provisionTest);
}
var testProgress = provisionTest.EndUserMessage;
var deprovisionTest = Deprovision(dpr);
if (!deprovisionTest.IsSuccess)
{
return(deprovisionTest);
}
testProgress += deprovisionTest.EndUserMessage;
testResult.IsSuccess = true;
testResult.EndUserMessage = testProgress;
return(testResult);
}
public override OperationResult Test(AddonTestRequest request)
{
AddonManifest manifest = request.Manifest;
string developerOptions = request.DeveloperOptions;
var testResult = new OperationResult {
IsSuccess = false
};
var testProgress = "";
//string jobid = null;
if (manifest.Properties != null && manifest.Properties.Any())
{
EMRDeveloperOptions devOptions;
testProgress += "Evaluating required manifest properties...\n";
if (!ValidateManifest(manifest, out testResult))
{
return(testResult);
}
var parseOptionsResult = ParseDevOptions(developerOptions, out devOptions);
if (!parseOptionsResult.IsSuccess)
{
return(parseOptionsResult);
}
testProgress += parseOptionsResult.EndUserMessage;
try
{
testProgress += "Establishing connection to AWS...\n";
IAmazonElasticMapReduce client;
var establishClientResult = EstablishClient(manifest, devOptions, out client);
if (!establishClientResult.IsSuccess)
{
return(establishClientResult);
}
testProgress += establishClientResult.EndUserMessage;
testProgress += "Successfully passed all testing criteria!";
testResult.IsSuccess = true;
testResult.EndUserMessage = testProgress;
}
catch (Exception e)
{
testResult.EndUserMessage = e.Message;
}
}
else
{
testResult.EndUserMessage = "Missing required manifest properties (requireDevCredentials)";
}
return(testResult);
}
public override OperationResult Test(AddonTestRequest request)
{
/*The test method allows you to test whether the Add-On was developed and configured properly and that any dependent systems are
* operating normally. During this method, you will want to go through a similar workflow to Provision to ensure proper functioning
* of the Add-On.*/
return(new OperationResult {
EndUserMessage = "The Add-On was tested successfully", IsSuccess = true
});
}
public void AddonTest()
{
// Arrange
var request = new AddonTestRequest
{
DeveloperParameters = new[]
{
new AddonParameter
{
Key = "VolumeSize",
Value = "1Gi"
}
},
Manifest = new AddonManifest
{
ProvisioningLocation = "https://ash:6443",
Properties = new List <AddonProperty>
{
new AddonProperty
{
Key = AddonManifest.InstanceAliasPropertyKey,
Value = "test"
},
new AddonProperty
{
Key = "StorageClass",
Value = "glusterfs"
},
new AddonProperty
{
Key = "Namespace",
Value = "acp"
},
new AddonProperty
{
Key = "Certificate",
Value = "client.pfx"
},
new AddonProperty
{
Key = "Password",
Value = "password"
}
}
}
};
var addon = new Addon();
// Act
var result = addon.Test(request);
// Assert
Assert.IsTrue(result.IsSuccess, result.EndUserMessage);
}
public RabbitMQConfig(AddonTestRequest request)
{
Hostname = request.Manifest.Properties.Single(p => p.Key == RabbitEndpointKey).Value;
var portString = request.Manifest.Properties.Single(p => p.Key == RabbitPortKey).Value;
Port = int.Parse(portString);
var adminPortString = request.Manifest.Properties.Single(p => p.Key == RabbitAdminPortKey).Value;
AdminPort = int.Parse(adminPortString);
AdminUser = request.Manifest.Properties.Single(p => p.Key == RabbitAdminUserKey).Value;
AdminPassword = request.Manifest.Properties.Single(p => p.Key == RabbitAdminPasswordKey).Value;
}
public void SetupManifest()
{
ProvisionRequest = new AddonProvisionRequest {
Manifest = SetupPropertiesAndParameters()
};
DeprovisionRequest = new AddonDeprovisionRequest {
Manifest = SetupPropertiesAndParameters()
};
TestRequest = new AddonTestRequest {
Manifest = SetupPropertiesAndParameters()
};
}
public void SocTest()
{
this.TestRequest = new AddonTestRequest()
{
Manifest = SetupPropertiesAndParameters(),
DeveloperParameters = SetUpParameters()
};
var output = new MongoDbAddOn().Test(this.TestRequest);
Assert.That(output, Is.TypeOf <OperationResult>());
Assert.That(output.IsSuccess, Is.EqualTo(true));
}
public override OperationResult Test(AddonTestRequest request)
{
var testProgress = "";
var testResult = new OperationResult {
IsSuccess = false
};
var manifest = request.Manifest;
var developerParameters = request.DeveloperParameters;
var developerOptions = GoogleCloudDeveloperOptions.Parse(developerParameters);
testProgress += "Attempting to add an instance...";
try
{
//add instance
var op = new InstanceOperations(manifest, developerOptions);
op.AddInstance();
testProgress += "Successfully added instance.\n";
//wait for instance to finishing adding
Thread.Sleep(120000);
try
{
//remove instance
testProgress += "Attempting to remove an instance...";
op.RemoveInstance();
testProgress += "Successfully removed instance.\n";
testResult.IsSuccess = true;
}
catch (AggregateException e)
{
foreach (var err in e.InnerExceptions)
{
Log.Error("Error occurred during test of Google Cloud Addon", err);
testProgress += "EXCEPTION: " + err + "\n";
}
testProgress += "Failed to remove instance \n";
}
}
catch (AggregateException e)
{
foreach (var err in e.InnerExceptions)
{
Log.Error("Error occurred during test of Google Cloud Addon", err);
testProgress += "EXCEPTION: " + err + "\n";
}
testProgress += "Failed to add instance \n";
}
testResult.EndUserMessage = testProgress;
return(testResult);
}
public void SetupManifest()
{
this.ProvisionRequest = new AddonProvisionRequest
{
Manifest = SetupPropertiesAndParameters(),
DeveloperParameters = SetUpParameters()
};
this.DeprovisionRequest = new AddonDeprovisionRequest {
Manifest = SetupPropertiesAndParameters()
};
this.TestRequest = new AddonTestRequest {
Manifest = SetupPropertiesAndParameters()
};
}
public static void TestSuccessfullyConnectionToAWS()
{
var addon = new Addon();
var manifest = GetAWSAddonManifest();
manifest.Properties.First(p => p.Key == "requireDevCredentials").Value = "false";
manifest.ProvisioningUsername = awsAccessKey;
manifest.ProvisioningPassword = awsSecretKey;
var request = new AddonTestRequest {
Manifest = manifest, DeveloperOptions = ""
};
var result = addon.Test(request);
Assert.IsTrue(result.IsSuccess, result.EndUserMessage);
}
public override OperationResult Test(AddonTestRequest request)
{
var rabbitConfig = new RabbitMQConfig(request);
var factory = new ConnectionFactory()
{
HostName = rabbitConfig.Hostname, UserName = rabbitConfig.AdminUser, Password = rabbitConfig.AdminPassword, Port = rabbitConfig.Port, RequestedConnectionTimeout = 20000
};
using (var connection = factory.CreateConnection())
{
using (var channel = connection.CreateModel())
{
channel.QueueDeclare(queue: "AddOnTestQueue",
durable: false,
exclusive: false,
autoDelete: false,
arguments: null);
string sendMessage = "Hello from Test method!";
var sendBody = Encoding.UTF8.GetBytes(sendMessage);
channel.BasicPublish(exchange: "",
routingKey: "AddOnTestQueue",
basicProperties: null,
body: sendBody);
Console.WriteLine(" [x] Sent {0}", sendMessage);
Thread.Sleep(100);
var result = channel.BasicGet(queue: "AddOnTestQueue", noAck: false);
var recvBody = result.Body;
channel.BasicAck(result.DeliveryTag, false);
var recvMessage = Encoding.UTF8.GetString(recvBody);
Console.WriteLine(" [x] Received {0}", recvMessage);
Assert.AreEqual(sendBody, recvBody);
Assert.AreEqual(sendMessage, recvMessage);
return(new OperationResult()
{
IsSuccess = true, EndUserMessage = ""
});
}
}
}
public static void TestManifestMissingCredProperty()
{
var addon = new Addon();
var manifest = GetAWSAddonManifest();
manifest.Properties.Clear();
manifest.Properties.Add(new AddonProperty {
Key = "randomProperty", Value = "randomValue"
});
var request = new AddonTestRequest {
Manifest = manifest, DeveloperOptions = ""
};
var result = addon.Test(request);
Assert.IsFalse(result.IsSuccess);
Assert.IsTrue(result.EndUserMessage.Contains("Missing required property"), result.EndUserMessage);
}
public void TestTestMethod()
{
var testRequest = new AddonTestRequest();
var properties = new List <AddonProperty>();
properties.Add(new AddonProperty()
{
Key = "RabbitEndpoint", Value = "hqs-engineer15.apprendalabs.local"
});
properties.Add(new AddonProperty()
{
Key = "RabbitAdminPort", Value = "15672"
});
properties.Add(new AddonProperty()
{
Key = "RabbitPort", Value = "5672"
});
properties.Add(new AddonProperty()
{
Key = "RabbitAdminUser", Value = "guest"
});
properties.Add(new AddonProperty()
{
Key = "RabbitAdminPassword", Value = "guest"
});
properties.Add(new AddonProperty()
{
Key = "DeveloperAlias", Value = "unit"
});
properties.Add(new AddonProperty()
{
Key = "InstanceAlias", Value = "sampleId"
});
testRequest.Manifest = ReadTestManifest("UnitTestAddOnManifest.xml");
testRequest.Manifest.Properties = properties;
var addon = new RabbitMQAddOn.RabbitMQAddOn();
var result = addon.Test(testRequest);
Assert.IsNotNull(result);
}
public override OperationResult Test(AddonTestRequest request)
{
var manifest = request.Manifest;
var developerParams = request.DeveloperParameters;
var testResult = new OperationResult {
IsSuccess = false
};
var testProgress = "";
var manifestProperties = manifest.Properties;
if (manifestProperties != null)
{
var devOptions = DeveloperParameters.Parse(developerParams, manifest.GetProperties());
var creds = CertificateAuthenticationHelper.GetCredentials(devOptions.AzureManagementSubscriptionId,
devOptions.AzureAuthenticationKey, devOptions.PFXPassword);
try
{
testProgress += "Establishing connection to Azure...\n";
// set up the credentials for azure
var client = new StorageManagementClient(creds);
//var listOfStorageAccounts = client.StorageAccounts.List();
testProgress += "Successfully passed all testing criteria!";
testResult.IsSuccess = true;
testResult.EndUserMessage = testProgress;
}
catch (Exception e)
{
// adding a forced failure here.
testResult.IsSuccess = false;
testResult.EndUserMessage = testProgress + "\nEXCEPTION: " + e.Message;
}
}
else
{
testResult.IsSuccess = false;
testResult.EndUserMessage = "Missing required manifest properties (requireDevCredentials)";
}
return(testResult);
}
static void Main(string[] args)
{
var addon = new Addon();
var manifest = new AddonManifest
{
Author = "Abraham Sultan",
Vendor = "Apprenda Inc.",
Version = "1.0.0.0",
IsEnabled = true,
Name = "AWS RDS",
Properties = new List<AddonProperty>()
{
new AddonProperty(){Key = "requireDevCredentials", Value = "true"}
}
};
var request = new AddonTestRequest { Manifest = manifest, DeveloperOptions = "" };
addon.Test(request);
}
public override OperationResult Test(AddonTestRequest request)
{
try
{
GetListenerUrl(request.Manifest);
return(new OperationResult()
{
EndUserMessage = "AddOn test was successful!",
IsSuccess = true
});
}
catch (Exception ex)
{
return(new OperationResult()
{
IsSuccess = false,
EndUserMessage = $"AddOn test failed with message {ex.Message}. StackTrace: {ex.StackTrace}"
});
}
}
public override OperationResult Test(AddonTestRequest request)
{
var result = new OperationResult();
try
{
NewDatabase = GetDatabaseName(request.Manifest);
NewUserId = GetNewUsername(request.Manifest);
NewPassword = GetPassword();
log.InfoFormat("Creating and removing MsSql database: {0}", NewDatabase);
using (var connection = GetConnection(request.Manifest.Properties))
{
CreateDatabase(connection);
CreateUser(connection);
GrantPrivileges(connection);
DropUser(connection);
DropDatabase(connection);
}
result.IsSuccess = true;
result.EndUserMessage = "Successfully created and removed a MsSql database.";
log.InfoFormat("Successfully created and removed MsSql database: {0}", NewDatabase);
}
catch (Exception ex)
{
result.IsSuccess = false;
result.EndUserMessage = ex.Message;
log.ErrorFormat("Failed to create or remove MsSql database '{0}': {1}", NewDatabase, ex.Message);
log.Error(ex.StackTrace);
}
return(result);
}
public override OperationResult Test(AddonTestRequest request)
{
var manifest = request.Manifest;
var inputDevParams = request.DeveloperParameters;
var testResult = new OperationResult {
IsSuccess = false
};
var testProgress = "";
var manifestProperties = manifest.Properties;
if (manifestProperties != null && manifestProperties.Any())
{
var devParams = DeveloperParameters.Parse(inputDevParams, manifestProperties);
try
{
testProgress += "Establishing connection to Azure...\n";
// set up the credentials for azure
var client = EstablishClient(devParams);
var listOfStorageAccounts = client.StorageAccounts.List();
testProgress += $"Number of Accounts: '{listOfStorageAccounts.Count()}'";
testProgress += "Successfully passed all testing criteria!";
testResult.IsSuccess = true;
testResult.EndUserMessage = testProgress;
}
catch (Exception e)
{
testResult.EndUserMessage = e.Message;
}
}
else
{
testResult.EndUserMessage = "Missing required manifest properties (requireDevCredentials)";
}
return(testResult);
}
public static void TestMissingDevCreds()
{
var addon = new Addon();
var manifest = GetAWSAddonManifest();
var request = new AddonTestRequest {
Manifest = manifest, DeveloperOptions = ""
};
var result = addon.Test(request);
Assert.IsFalse(result.IsSuccess);
Assert.IsTrue(result.EndUserMessage.Contains("requires that developer credentials are specified"), result.EndUserMessage);
request.DeveloperOptions = "accessKey=abe";
result = addon.Test(request);
Assert.IsFalse(result.IsSuccess);
Assert.IsTrue(result.EndUserMessage.Contains("requires that developer credentials are specified"), result.EndUserMessage);
request.DeveloperOptions = "secretKey=secret";
result = addon.Test(request);
Assert.IsFalse(result.IsSuccess);
Assert.IsTrue(result.EndUserMessage.Contains("requires that developer credentials are specified"), result.EndUserMessage);
}
public override OperationResult Test(AddonTestRequest _request)
{
/*The test method allows you to test whether the Add-On was developed and configured properly and that any dependent systems are
* operating normally. During this method, you will want to go through a similar workflow to Provision to ensure proper functioning
* of the Add-On.*/
var manifest = _request.Manifest;
var devParameters = _request.DeveloperParameters;
var devOptions = WCDeveloperOptions.Parse(devParameters, manifest);
var testResult = new OperationResult {
EndUserMessage = string.Empty, IsSuccess = false
};
cloud_url = devOptions.cloudurl;
appalias = devOptions.alias;
try
{
var token = authenticate(devOptions.apprendausername, devOptions.apprendapassword, devOptions.apprendatenant);
int statusCode = getApp(token, appalias);
if (statusCode != 200)
{
throw new Exception("Watson Conversation API has not successfully been deployed in Apprenda");
}
}
catch (Exception ex)
{
var errorMessage = string.Format("WatsonConversationAddon Testing Error: {0}\n{1}", ex, ex.StackTrace);
log.Error(errorMessage);
testResult.EndUserMessage = errorMessage;
return(testResult);
}
testResult.EndUserMessage = "WatsonConversationAddon Add-On was tested successfully";
testResult.IsSuccess = true;
return(testResult);
}
// Testing Instance
// Input: AddonTestRequest request
// Output: OperationResult
public override OperationResult Test(AddonTestRequest request)
{
var provisionRequest = new AddonProvisionRequest {
Manifest = request.Manifest, DeveloperOptions = request.DeveloperOptions
};
var manifest = request.Manifest;
var developerOptions = request.DeveloperOptions;
var testResult = new OperationResult {
IsSuccess = false
};
var testProgress = "";
if (manifest.Properties != null && manifest.Properties.Any())
{
S3DeveloperOptions devOptions;
testProgress += "Evaluating required manifest properties...\n";
if (!ValidateManifest(manifest, out testResult))
{
return(testResult);
}
var parseOptionsResult = ParseDevOptions(developerOptions, out devOptions);
if (!parseOptionsResult.IsSuccess)
{
return(parseOptionsResult);
}
testProgress += parseOptionsResult.EndUserMessage;
try
{
testProgress += "Establishing connection to AWS...\n";
AmazonS3Client client;
var establishClientResult = EstablishClient(manifest, devOptions, out client);
if (!establishClientResult.IsSuccess)
{
return(establishClientResult);
}
testProgress += establishClientResult.EndUserMessage;
testProgress += "Successfully connected. \n";
testResult.IsSuccess = true;
testResult.EndUserMessage = testProgress;
// ok and let let's try provisioning
var result = Provision(provisionRequest);
testResult.EndUserMessage += result.IsSuccess + "\n";
testResult.EndUserMessage += result.ConnectionData + "\n";
testResult.EndUserMessage += result.EndUserMessage + "\n";
var depResult = Deprovision(new AddonDeprovisionRequest {
ConnectionData = result.ConnectionData, DeveloperOptions = provisionRequest.DeveloperOptions, Manifest = provisionRequest.Manifest
});
if (depResult == null)
{
throw new ArgumentNullException("request");
}
testResult.EndUserMessage += depResult.IsSuccess + "\n";
testResult.EndUserMessage += depResult.EndUserMessage;
}
catch (Exception e)
{
testResult.EndUserMessage = e.Message + e.StackTrace;
}
}
else
{
testResult.EndUserMessage = "Missing required manifest properties (requireDevCredentials)";
}
return(testResult);
}
public override OperationResult Test(AddonTestRequest request)
{
return new OperationResult()
{
EndUserMessage = "Testing complete, but still need to build out a few more things.",
IsSuccess = true
};
}
public override OperationResult Test(AddonTestRequest request)
{
var manifest = request.Manifest;
var developerParams = request.DeveloperParameters;
var testResult = new OperationResult { IsSuccess = false };
var testProgress = "";
var manifestProperties = manifest.Properties;
if (manifestProperties != null)
{
var devOptions = DeveloperParameters.Parse(developerParams, manifest.GetProperties());
var creds = CertificateAuthenticationHelper.GetCredentials(devOptions.AzureManagementSubscriptionId,
devOptions.AzureAuthenticationKey);
try
{
testProgress += "Establishing connection to Azure...\n";
// set up the credentials for azure
var client = new StorageManagementClient(creds);
var listOfStorageAccounts = client.StorageAccounts.List();
testProgress += "Successfully passed all testing criteria!";
testResult.IsSuccess = true;
testResult.EndUserMessage = testProgress;
}
catch (Exception e)
{
// adding a forced failure here.
testResult.IsSuccess = false;
testResult.EndUserMessage = testProgress + "\nEXCEPTION: " + e.Message;
}
}
else
{
testResult.IsSuccess = false;
testResult.EndUserMessage = "Missing required manifest properties (requireDevCredentials)";
}
return testResult;
}
public override OperationResult Test(AddonTestRequest request)
{
throw new System.NotImplementedException();
}
public void SetupManifest()
{
ProvisionRequest = new AddonProvisionRequest {Manifest = SetupPropertiesAndParameters()};
DeprovisionRequest = new AddonDeprovisionRequest {Manifest = SetupPropertiesAndParameters()};
TestRequest = new AddonTestRequest {Manifest = SetupPropertiesAndParameters()};
}
// Testing Instance // Input: AddonTestRequest request // Output: OperationResult public abstract override OperationResult Test(AddonTestRequest request);
// Testing Instance
// Input: AddonTestRequest request
// Output: OperationResult
public override OperationResult Test(AddonTestRequest request)
{
AddonManifest manifest = request.Manifest;
string developerOptions = request.DeveloperOptions;
var testResult = new OperationResult { IsSuccess = false };
var testProgress = "";
if (manifest.Properties != null && manifest.Properties.Any())
{
DeveloperOptions devOptions;
testProgress += "Evaluating required manifest properties...\n";
if (!ValidateManifest(manifest, out testResult))
{
return testResult;
}
var parseOptionsResult = ParseDevOptions(developerOptions, out devOptions);
if (!parseOptionsResult.IsSuccess)
{
return parseOptionsResult;
}
testProgress += parseOptionsResult.EndUserMessage;
try
{
testProgress += "Establishing connection to AWS...\n";
AmazonSimpleNotificationServiceClient client;
var establishClientResult = EstablishClient(manifest, devOptions, out client);
if (!establishClientResult.IsSuccess)
{
return establishClientResult;
}
testProgress += establishClientResult.EndUserMessage;
var platformApps = client.ListPlatformApplications();
testProgress += "Successfully passed all testing criteria!";
testResult.IsSuccess = true;
testResult.EndUserMessage = testProgress;
}
catch (Exception e)
{
testResult.EndUserMessage = e.Message;
}
}
else
{
testResult.EndUserMessage = "Missing required manifest properties (requireDevCredentials)";
}
return testResult;
}
public override OperationResult Test(AddonTestRequest request)
{
var manifest = request.Manifest;
var inputDevParams = request.DeveloperParameters;
var testResult = new OperationResult {IsSuccess = false};
var testProgress = "";
var manifestProperties = manifest.Properties;
if (manifestProperties != null && manifestProperties.Any())
{
var devParams = DeveloperParameters.Parse(inputDevParams, manifestProperties);
try
{
testProgress += "Establishing connection to Azure...\n";
// set up the credentials for azure
var client = EstablishClient(devParams);
var listOfStorageAccounts = client.StorageAccounts.List();
testProgress += $"Number of Accounts: '{listOfStorageAccounts.Count()}'";
testProgress += "Successfully passed all testing criteria!";
testResult.IsSuccess = true;
testResult.EndUserMessage = testProgress;
}
catch (Exception e)
{
testResult.EndUserMessage = e.Message;
}
}
else
{
testResult.EndUserMessage = "Missing required manifest properties (requireDevCredentials)";
}
return testResult;
}
public override OperationResult Test(AddonTestRequest request)
{
if (request == null)
{
return(FaultResult("The Syslog addon received a Test call without a valid Request"));
}
var host = request.Manifest.Properties.First(p => p.Key.Equals("Host")).Value;
var portValue = request.Manifest.Properties.First(p => p.Key.Equals("Port")).Value;
var protocol = request.Manifest.Properties.First(p => p.Key.Equals("Protocol")).Value;
var mapType = request.Manifest.Properties.First(p => p.Key.Equals("MapType")).Value;
var flavor = request.Manifest.Properties.First(p => p.Key.Equals("Flavor")).Value;
IPAddress asIp;
if (!IPAddress.TryParse(host, out asIp))
{
var hostEntry = Dns.GetHostEntry(host);
if (hostEntry.AddressList.Any())
{
asIp = hostEntry.AddressList.First();
}
else
{
return(FaultResult($"Could not resolve {host} as an IP address or hostname."));
}
}
int port;
if (!int.TryParse(portValue, out port))
{
return(FaultResult("Could not parse {portValue} as a portnumber."));
}
switch (protocol.ToUpperInvariant())
{
case "TCP":
try
{
TestTcpConnection(asIp, port);
}
catch
{
return(FaultResult($"There was a failure connecting to tcp endpoint {host}:{port}."));
}
break;
case "UDP":
try
{
TestUdpConnection(asIp, port);
}
catch
{
return(FaultResult($"There was a failure connecting to udp endpoint {host}:{port}."));
}
break;
case "ENCRYPTEDTCP":
// TODO: implement encrypted TCP test connection.
break;
default:
return(FaultResult($"Unsupported protocol {protocol}"));
}
using (var sender = CreateSender(protocol, host, port))
{
var serializer = CreateSerializer(flavor);
// ReSharper disable once RedundantExplicitParamsArrayCreation - SyslogNet does not handle the params array properly during serialization without explicitly creating the empty array.
var message = new SyslogMessage(DateTimeOffset.Now, Facility.LogAudit, Severity.Informational, Environment.MachineName, "Apprenda.AddOns.Syslog", "-", "TEST", "Connection test message", new StructuredDataElement[0]);
sender.Send(message, serializer);
}
mapType.ToUpperInvariant().Should().BeOneOf("DEFAULT", "8.1", "8.1CEF");
return(SuccessResult("The Syslog addon connected successfully."));
}
// Testing Instance
// Input: AddonTestRequest request
// Output: OperationResult
public override OperationResult Test(AddonTestRequest request)
{
var provisionRequest = new AddonProvisionRequest { Manifest = request.Manifest, DeveloperOptions = request.DeveloperOptions };
var manifest = request.Manifest;
var developerOptions = request.DeveloperOptions;
var testResult = new OperationResult { IsSuccess = false };
var testProgress = "";
if (manifest.Properties != null && manifest.Properties.Any())
{
S3DeveloperOptions devOptions;
testProgress += "Evaluating required manifest properties...\n";
if (!ValidateManifest(manifest, out testResult))
{
return testResult;
}
var parseOptionsResult = ParseDevOptions(developerOptions, out devOptions);
if (!parseOptionsResult.IsSuccess)
{
return parseOptionsResult;
}
testProgress += parseOptionsResult.EndUserMessage;
try
{
testProgress += "Establishing connection to AWS...\n";
AmazonS3Client client;
var establishClientResult = EstablishClient(manifest, devOptions, out client);
if (!establishClientResult.IsSuccess)
{
return establishClientResult;
}
testProgress += establishClientResult.EndUserMessage;
testProgress += "Successfully connected. \n";
testResult.IsSuccess = true;
testResult.EndUserMessage = testProgress;
// ok and let let's try provisioning
var result = Provision(provisionRequest);
testResult.EndUserMessage += result.IsSuccess + "\n";
testResult.EndUserMessage += result.ConnectionData + "\n";
testResult.EndUserMessage += result.EndUserMessage + "\n";
var depResult = Deprovision(new AddonDeprovisionRequest { ConnectionData = result.ConnectionData, DeveloperOptions = provisionRequest.DeveloperOptions, Manifest = provisionRequest.Manifest });
if (depResult == null)
{
throw new ArgumentNullException("request");
}
testResult.EndUserMessage += depResult.IsSuccess + "\n";
testResult.EndUserMessage += depResult.EndUserMessage;
}
catch (Exception e)
{
testResult.EndUserMessage = e.Message + e.StackTrace;
}
}
else
{
testResult.EndUserMessage = "Missing required manifest properties (requireDevCredentials)";
}
return testResult;
}
// Testing Instance // Input: AddonTestRequest request // Output: OperationResult public abstract override OperationResult Test(AddonTestRequest request);
