public void RabbitMQSource_NewConnection_GivenNoArgConstructor_ConnectionSuccess()
{
//-------------------------------Arrange-----------------------------
var port = 5672;
var hostName = Depends.EnableDocker?Depends.RigOpsIP:Depends.SVRDEVIP;
var userName = "******";
var password = "******";
var virtualHost = "/";
var rabbitMqSource = new RabbitMQSource
{
HostName = hostName,
UserName = userName,
Password = password,
Port = port,
VirtualHost = virtualHost,
};
//----------------------Pre-Assert---------------------------------
Assert.AreEqual(nameof(RabbitMQSource), rabbitMqSource.ResourceType);
Assert.AreEqual(5672, rabbitMqSource.Port);
Assert.AreEqual(Depends.EnableDocker?Depends.RigOpsIP:Depends.SVRDEVIP, rabbitMqSource.HostName);
Assert.AreEqual("test", rabbitMqSource.UserName);
Assert.AreEqual("test", rabbitMqSource.Password);
Assert.AreEqual("/", rabbitMqSource.VirtualHost);
//-------------------------------Act---------------------------------
using (var rabbitConnection = rabbitMqSource.NewConnection())
{
//-------------------------------Assert------------------------------
Assert.IsTrue(rabbitConnection.IsOpen);
}
}
public void RabbitMQSource_NewConnection_Success()
{
//-------------------------------Arrange-----------------------------
string xmlString = $@"<Source ID=""1a82a341-b678-4992-a25a-39cdd57198d4"" Name=""Example Rabbit MQ Source"" ResourceType=""RabbitMQSource"" IsValid=""false""
ConnectionString=""HostName={(Depends.EnableDocker?Depends.RigOpsIP:Depends.SVRDEVIP)};Port=;UserName=test;Password=test;VirtualHost=/"" Type=""RabbitMQSource"" ServerVersion=""1.4.1.27"" ServerID=""693ca20d-fb17-4044-985a-df3051d6bac7"">
<DisplayName>Example Rabbit MQ Source</DisplayName>
<AuthorRoles>
</AuthorRoles>
<ErrorMessages />
<TypeOf>RabbitMQSource</TypeOf>
<VersionInfo DateTimeStamp=""2017-05-26T14:21:24.3247847+02:00"" Reason="""" User=""NT AUTHORITY\SYSTEM"" VersionNumber=""1"" ResourceId=""1a82a341-b678-4992-a25a-39cdd57198d4"" VersionId=""b1a6de00-3cac-41cd-b0ed-9fac9bb61266"" />
</Source>";
var xElement = XElement.Parse(xmlString);
var rabbitMqSource = new RabbitMQSource(xElement);
//----------------------Pre-Assert---------------------------------
Assert.AreEqual(nameof(RabbitMQSource), rabbitMqSource.ResourceType);
Assert.AreEqual(5672, rabbitMqSource.Port);
Assert.AreEqual(Depends.EnableDocker?Depends.RigOpsIP:Depends.SVRDEVIP, rabbitMqSource.HostName);
Assert.AreEqual("test", rabbitMqSource.UserName);
Assert.AreEqual("test", rabbitMqSource.Password);
Assert.AreEqual("/", rabbitMqSource.VirtualHost);
//-------------------------------Act---------------------------------
using (var rabbitConnection = rabbitMqSource.NewConnection())
{
//-------------------------------Assert------------------------------
Assert.IsTrue(rabbitConnection.IsOpen);
}
}
public void RabbitMQSource_Validate_ToXml_DefaultValues()
{
const string xmlString = @"<Source ID=""1a82a341-b678-4992-a25a-39cdd57198d4"" Name=""Example Rabbit MQ Source"" ResourceType=""RabbitMQSource"" IsValid=""false""
ConnectionString=""HostName=localhost;Port=;UserName=warewolf;Password=test123;VirtualHost=hostyhost/"" Type=""RabbitMQSource"" ServerVersion=""1.4.1.27"" ServerID=""693ca20d-fb17-4044-985a-df3051d6bac7"">
<DisplayName>Example Rabbit MQ Source</DisplayName>
<AuthorRoles>
</AuthorRoles>
<ErrorMessages />
<TypeOf>RabbitMQSource</TypeOf>
<VersionInfo DateTimeStamp=""2017-05-26T14:21:24.3247847+02:00"" Reason="""" User=""NT AUTHORITY\SYSTEM"" VersionNumber=""3"" ResourceId=""1a82a341-b678-4992-a25a-39cdd57198d4"" VersionId=""b1a6de00-3cac-41cd-b0ed-9fac9bb61266"" />
</Source>";
var xElement = XElement.Parse(xmlString);
var rabbitMqSource = new RabbitMQSource(xElement);
var result = rabbitMqSource.ToXml();
var rabbitMqSourceWithXml = new RabbitMQSource(result);
Assert.AreEqual(nameof(RabbitMQSource), rabbitMqSourceWithXml.ResourceType);
Assert.AreEqual(5672, rabbitMqSourceWithXml.Port);
Assert.AreEqual("localhost", rabbitMqSourceWithXml.HostName);
Assert.AreEqual("warewolf", rabbitMqSourceWithXml.UserName);
Assert.AreEqual("test123", rabbitMqSourceWithXml.Password);
Assert.AreEqual("hostyhost/", rabbitMqSourceWithXml.VirtualHost);
}
public void RabbitMQSource_GivenXElement_WithoutValues_Constructor_Validate_DefaultValues()
{
const string xmlString = @"<Source ID=""2aa3fdba-e0c3-47dd-8dd5-e6f24aaf5c7a"" Name=""test server"" Type=""Dev2Server"" ConnectionString=""AppServerUri=http://178.63.172.163:3142/dsf;WebServerPort=3142;AuthenticationType=Public;UserName=;Password="" Version=""1.0"" ResourceType=""Server"" ServerID=""51a58300-7e9d-4927-a57b-e5d700b11b55"">
<TypeOf>Dev2Server</TypeOf>
<DisplayName>test server</DisplayName>
<Category>WAREWOLF SERVERS</Category>
<Signature xmlns=""http://www.w3.org/2000/09/xmldsig#"">
<SignedInfo>
<CanonicalizationMethod Algorithm=""http://www.w3.org/TR/2001/REC-xml-c14n-20010315"" />
<SignatureMethod Algorithm=""http://www.w3.org/2000/09/xmldsig#rsa-sha1"" />
<Reference URI="""">
<Transforms>
<Transform Algorithm=""http://www.w3.org/2000/09/xmldsig#enveloped-signature"" />
</Transforms>
<DigestMethod Algorithm=""http://www.w3.org/2000/09/xmldsig#sha1"" />
<DigestValue>1ia51dqx+BIMQ4QgLt+DuKtTBUk=</DigestValue>
</Reference>
</SignedInfo>
<SignatureValue>Wqd39EqkFE66XVETuuAqZveoTk3JiWtAk8m1m4QykeqY4/xQmdqRRSaEfYBr7EHsycI3STuILCjsz4OZgYQ2QL41jorbwULO3NxAEhu4nrb2EolpoNSJkahfL/N9X5CvLNwpburD4/bPMG2jYegVublIxE50yF6ZZWG5XiB6SF8=</SignatureValue>
</Signature>
</Source>";
var xElement = XElement.Parse(xmlString);
var rabbitMqSource = new RabbitMQSource(xElement);
Assert.AreEqual(nameof(RabbitMQSource), rabbitMqSource.ResourceType);
Assert.AreEqual(5672, rabbitMqSource.Port);
Assert.AreEqual("", rabbitMqSource.HostName);
Assert.AreEqual("", rabbitMqSource.UserName);
Assert.AreEqual("", rabbitMqSource.Password);
Assert.AreEqual("/", rabbitMqSource.VirtualHost);
}
public IRabbitMQServiceSourceDefinition FetchSource(Guid resourceID)
{
var xaml = _queryManager.FetchResourceXaml(resourceID);
var source = new RabbitMQSource(xaml.ToXElement());
var def = new RabbitMQServiceSourceDefinition(source);
return(def);
}
public void RabbitMQPublishDesignerViewModel2_Constructor2()
{
//------------Setup for test--------------------------
CustomContainer.LoadedTypes = new List <Type>
{
typeof(ManageRabbitMQSourceModel)
};
var mockHelpViewModel = new Mock <IHelpWindowViewModel>();
mockHelpViewModel.Setup(model => model.UpdateHelpText(It.IsAny <string>())).Verifiable();
var mockUpdateManager = new Mock <IStudioUpdateManager>();
var mockQueryManager = new Mock <IQueryManager>();
var guidOne = Guid.NewGuid();
var guidTwo = Guid.NewGuid();
var rabbitMqSourceOne = new RabbitMQSource {
ResourceID = guidOne, ResourceName = "ResourceOne", HostName = "HostOne"
};
var rabbitMqSourceTwo = new RabbitMQSource {
ResourceID = guidTwo, ResourceName = "ResourceTwo", HostName = "HostTwo"
};
var rabbitMqServiceSourceDefinitions = new List <IRabbitMQServiceSourceDefinition>
{
new RabbitMQServiceSourceDefinition(rabbitMqSourceOne),
new RabbitMQServiceSourceDefinition(rabbitMqSourceTwo),
};
mockQueryManager.Setup(o => o.FetchRabbitMQServiceSources()).Returns(rabbitMqServiceSourceDefinitions);
var server = new Mock <IServer>();
server.Setup(server1 => server1.UpdateRepository).Returns(mockUpdateManager.Object);
server.Setup(server1 => server1.QueryProxy).Returns(mockQueryManager.Object);
var mockMainViewModel = new Mock <IShellViewModel>();
mockMainViewModel.Setup(model => model.HelpViewModel).Returns(mockHelpViewModel.Object);
mockMainViewModel.Setup(model => model.ActiveServer).Returns(server.Object);
CustomContainer.Register(mockMainViewModel.Object);
var publishRabbitMqActivity = new PublishRabbitMQActivity();
//------------Execute Test---------------------------
var vm = new RabbitMQPublishDesignerViewModel2(ModelItemUtils.CreateModelItem(publishRabbitMqActivity));
//------------Assert Results-------------------------
Assert.AreEqual(2, vm.RabbitMQSources.Count);
Assert.AreEqual(guidOne, vm.RabbitMQSources[0].ResourceID);
Assert.AreEqual("ResourceOne", vm.RabbitMQSources[0].ResourceName);
Assert.AreEqual("HostOne", vm.RabbitMQSources[0].HostName);
Assert.AreEqual(guidTwo, vm.RabbitMQSources[1].ResourceID);
Assert.AreEqual("ResourceTwo", vm.RabbitMQSources[1].ResourceName);
Assert.AreEqual("HostTwo", vm.RabbitMQSources[1].HostName);
}
public void RabbitMQSource_Constructor_Validate_DefaultValues()
{
var rabbitMqSource = new RabbitMQSource();
Assert.IsNotNull(rabbitMqSource.ResourceID);
Assert.AreEqual(Guid.Empty, rabbitMqSource.ResourceID);
Assert.AreEqual(nameof(RabbitMQSource), rabbitMqSource.ResourceType);
Assert.AreEqual(5672, rabbitMqSource.Port);
Assert.AreEqual("/", rabbitMqSource.VirtualHost);
}
public void RabbitMQSource_ShouldHaveConstructorAndSetDefaultValues()
{
var mqSource = new RabbitMQSource();
Assert.IsNotNull(mqSource);
Assert.IsNotNull(mqSource.ResourceID);
Assert.AreEqual("RabbitMQSource", mqSource.ResourceType);
Assert.AreEqual(5672, mqSource.Port);
Assert.AreEqual("/", mqSource.VirtualHost);
}
public void RabbitMQSource_Validate_DefaultValues()
{
var rabbitMqSource = new RabbitMQSource();
Assert.IsTrue(rabbitMqSource.IsSource);
Assert.IsFalse(rabbitMqSource.IsService);
Assert.IsFalse(rabbitMqSource.IsFolder);
Assert.IsFalse(rabbitMqSource.IsReservedService);
Assert.IsFalse(rabbitMqSource.IsServer);
Assert.IsFalse(rabbitMqSource.IsResourceVersion);
}
public ValidationResult Test(RabbitMQSource source)
{
try
{
return(CanConnectServer(source));
}
catch (Exception ex)
{
RaiseError(ex);
return(new ValidationResult {
IsValid = false, ErrorMessage = ex.Message
});
}
}
protected override List <string> PerformExecution(Dictionary <string, string> evaluatedValues)
{
try
{
RabbitMQSource = ResourceCatalog.GetResource <RabbitMQSource>(GlobalConstants.ServerWorkspaceID, RabbitMQSourceResourceId);
if (RabbitMQSource == null)
{
return(new List <string> {
ErrorResource.RabbitSourceHasBeenDeleted
});
}
if (!evaluatedValues.TryGetValue("QueueName", out string queueName) ||
!evaluatedValues.TryGetValue("Message", out string message))
{
return(new List <string> {
ErrorResource.RabbitQueueNameAndMessageRequired
});
}
ConnectionFactory.HostName = RabbitMQSource.HostName;
ConnectionFactory.Port = RabbitMQSource.Port;
ConnectionFactory.UserName = RabbitMQSource.UserName;
ConnectionFactory.Password = RabbitMQSource.Password;
ConnectionFactory.VirtualHost = RabbitMQSource.VirtualHost;
using (Connection = ConnectionFactory.CreateConnection())
{
using (Channel = Connection.CreateModel())
{
Channel.ExchangeDeclare(queueName, ExchangeType.Direct, IsDurable, IsAutoDelete, null);
Channel.QueueDeclare(queueName, IsDurable, IsExclusive, IsAutoDelete, null);
Channel.QueueBind(queueName, queueName, "", new Dictionary <string, object>());
var basicProperties = Channel.CreateBasicProperties();
basicProperties.Persistent = true;
Channel.BasicPublish(queueName, "", basicProperties, Encoding.UTF8.GetBytes(message));
}
}
Dev2Logger.Debug($"Message published to queue {queueName}", GlobalConstants.WarewolfDebug);
return(new List <string> {
"Success"
});
}
catch (Exception ex)
{
Dev2Logger.Error("PublishRabbitMQActivity", ex, GlobalConstants.WarewolfError);
throw new Exception(ex.GetAllMessages());
}
}
protected override List <string> PerformExecution(Dictionary <string, string> evaluatedValues)
{
_messages = new List <string>();
try
{
RabbitSource =
ResourceCatalog.GetResource <RabbitMQSource>(GlobalConstants.ServerWorkspaceID,
RabbitMQSourceResourceId);
if (RabbitSource == null || RabbitSource.ResourceType != enSourceType.RabbitMQSource.ToString())
{
_messages.Add(ErrorResource.RabbitSourceHasBeenDeleted);
return(_messages);
}
if (!evaluatedValues.TryGetValue("QueueName", out var queueName))
{
_messages.Add(ErrorResource.RabbitQueueNameRequired);
return(_messages);
}
if (!evaluatedValues.TryGetValue("Prefetch", out var prefetch))
{
prefetch = string.Empty;
}
ConnectionFactory.HostName = RabbitSource.HostName;
ConnectionFactory.Port = RabbitSource.Port;
ConnectionFactory.UserName = RabbitSource.UserName;
ConnectionFactory.Password = RabbitSource.Password;
ConnectionFactory.VirtualHost = RabbitSource.VirtualHost;
using (Connection = ConnectionFactory.CreateConnection())
{
using (Channel = Connection.CreateModel())
{
PerformExecutionOnChannel(queueName, prefetch);
}
}
return(new List <string> {
_result
});
}
catch (Exception ex)
{
Dev2Logger.Error("ConsumeRabbitMQActivity", ex, GlobalConstants.WarewolfError);
throw new Exception(ex.GetAllMessages());
}
}
private static IWorkerContext ConstructWorkerContext(out RabbitMQSource rabbitSource, out RabbitMQSource rabbitSink)
{
var mockArgs = new Mock <IArgs>();
mockArgs.Setup(o => o.TriggerId).Returns(_resourceId.ToString());
mockArgs.Setup(o => o.ServerEndpoint).Returns(new Uri("http://somehost:1234"));
var mockResourceCatalogProxy = new Mock <IResourceCatalogProxy>();
var mockFilePath = new Mock <IFilePath>();
mockFilePath.Setup(o => o.GetDirectoryName(It.IsAny <string>())).Returns("C:\\ProgramData\\Warewolf\\Triggers\\Queue");
mockFilePath.Setup(o => o.GetFileName(It.IsAny <string>())).Returns(_resourceId.ToString() + ".bite");
rabbitSource = new RabbitMQSource
{
ResourceID = _sourceId,
HostName = "somehost",
ResourceName = "my somehost resource",
};
rabbitSink = new RabbitMQSource
{
ResourceID = _sinkId,
HostName = "somehost",
ResourceName = "my somehost resource",
};
mockResourceCatalogProxy.Setup(o => o.GetResourceById <RabbitMQSource>(GlobalConstants.ServerWorkspaceID, _sourceId)).Returns(rabbitSource);
mockResourceCatalogProxy.Setup(o => o.GetResourceById <RabbitMQSource>(GlobalConstants.ServerWorkspaceID, _sinkId)).Returns(rabbitSink);
var mockTriggerCatalog = new Mock <ITriggersCatalog>();
var triggerQueue = new TriggerQueue
{
QueueSourceId = _sourceId,
QueueSinkId = _sinkId,
Options = new IOption[] { new OptionBool {
Name = "Durable", Value = true
} },
ResourceId = _resourceId,
QueueName = _queueName,
WorkflowName = _workflowName,
Inputs = new List <IServiceInputBase> {
_expectedIServiceInput
},
};
mockTriggerCatalog.Setup(o => o.PathFromResourceId(It.IsAny <string>())).Returns("C:\\ProgramData\\Warewolf\\Triggers\\Queue");
mockTriggerCatalog.Setup(o => o.LoadQueueTriggerFromFile(It.IsAny <string>())).Returns(triggerQueue);
return(new WorkerContext(mockArgs.Object, mockResourceCatalogProxy.Object, mockTriggerCatalog.Object, mockFilePath.Object));
}
ValidationResult CanConnectServer(RabbitMQSource rabbitMQSource)
{
try
{
IConnectionFactory connectionFactory = new ConnectionFactory()
{
HostName = rabbitMQSource.HostName,
Port = rabbitMQSource.Port,
UserName = rabbitMQSource.UserName,
Password = rabbitMQSource.Password,
VirtualHost = rabbitMQSource.VirtualHost
};
using (IConnection connection = connectionFactory.CreateConnection())
{
using (IModel channel = connection.CreateModel())
{
channel.QueueDeclare(queue: "TestRabbitMQServiceSource",
durable: false,
exclusive: false,
autoDelete: false,
arguments: null);
channel.BasicPublish(exchange: "",
routingKey: "TestRabbitMQServiceSource",
basicProperties: null,
body: Encoding.UTF8.GetBytes("Test Message"));
channel.QueueDeleteNoWait("TestRabbitMQServiceSource", true, false);
}
}
return(new ValidationResult
{
IsValid = true
});
}
catch (Exception e)
{
return(new ValidationResult
{
IsValid = false,
ErrorMessage = e.InnerException != null?string.Join(Environment.NewLine, e.Message, e.InnerException.Message) : e.Message
});
}
}
public void PerformSerialization_ShouldNotError()
{
//------------Setup for test--------------------------
var dsfConsumeRabbitMQActivity = new DsfConsumeRabbitMQActivity();
var resourceCatalog = new Mock <IResourceCatalog>();
var rabbitMQSource = new RabbitMQSource
{
HostName = "rsaklfsvrdev",
Port = 5672,
UserName = "******",
Password = "******"
};
resourceCatalog.Setup(r => r.GetResource <RabbitMQSource>(It.IsAny <Guid>(), It.IsAny <Guid>())).Returns(rabbitMQSource);
var privateObject = new PrivateObject(dsfConsumeRabbitMQActivity);
privateObject.SetProperty("ResourceCatalog", resourceCatalog.Object);
dsfConsumeRabbitMQActivity.ReQueue = true;
try
{
privateObject.Invoke("PerformExecution", new Dictionary <string, string> {
{ "QueueName", "HuggsTest" }
});
}
catch (Exception ex)
{
Assert.AreEqual("Queue Q1 not found", ex.Message);
}
Dev2JsonSerializer serializer = new Dev2JsonSerializer();
//------------Execute Test---------------------------
try
{
var serializedAct = serializer.SerializeToBuilder(dsfConsumeRabbitMQActivity);
//------------Assert Results-------------------------
Assert.IsNotNull(serializedAct);
}
catch (Exception e)
{
Assert.Fail(e.Message);
}
}
public void RabbitMQSource_NewConnection_GivenNoArgConstructor_ConnectionSuccess()
{
//-------------------------------Arrange-----------------------------
//const string xmlString = @"<Source ID=""1a82a341-b678-4992-a25a-39cdd57198d4"" Name=""Example Rabbit MQ Source"" ResourceType=""RabbitMQSource"" IsValid=""false""
// ConnectionString=""HostName=rsaklfsvrdev.dev2.local;Port=;UserName=test;Password=test;VirtualHost=/"" Type=""RabbitMQSource"" ServerVersion=""1.4.1.27"" ServerID=""693ca20d-fb17-4044-985a-df3051d6bac7"">
// <DisplayName>Example Rabbit MQ Source</DisplayName>
// <AuthorRoles>
// </AuthorRoles>
// <ErrorMessages />
// <TypeOf>RabbitMQSource</TypeOf>
// <VersionInfo DateTimeStamp=""2017-05-26T14:21:24.3247847+02:00"" Reason="""" User=""NT AUTHORITY\SYSTEM"" VersionNumber=""3"" ResourceId=""1a82a341-b678-4992-a25a-39cdd57198d4"" VersionId=""b1a6de00-3cac-41cd-b0ed-9fac9bb61266"" />
// </Source>";
var port = 5672;
var hostName = "rsaklfsvrdev.dev2.local";
var userName = "******";
var password = "******";
var virtualHost = "/";
var rabbitMqSource = new RabbitMQSource
{
HostName = hostName,
UserName = userName,
Password = password,
Port = port,
VirtualHost = virtualHost,
};
//----------------------Pre-Assert---------------------------------
Assert.AreEqual(nameof(RabbitMQSource), rabbitMqSource.ResourceType);
Assert.AreEqual(5672, rabbitMqSource.Port);
Assert.AreEqual("rsaklfsvrdev.dev2.local", rabbitMqSource.HostName);
Assert.AreEqual("test", rabbitMqSource.UserName);
Assert.AreEqual("test", rabbitMqSource.Password);
Assert.AreEqual("/", rabbitMqSource.VirtualHost);
//-------------------------------Act---------------------------------
using (var rabbitConnection = rabbitMqSource.NewConnection())
{
//-------------------------------Assert------------------------------
Assert.IsTrue(rabbitConnection.IsOpen);
}
}
public void RabbitMQSource_NewConnection_GivenNoArgConstructor_ConnectionSuccess()
{
//-------------------------------Arrange-----------------------------
var dependency = new Depends(Depends.ContainerType.RabbitMQ);
var port = int.Parse(dependency.Container.Port);
var hostName = dependency.Container.IP;
var userName = "******";
var password = "******";
var virtualHost = "/";
var rabbitMqSource = new RabbitMQSource
{
HostName = hostName,
UserName = userName,
Password = password,
Port = port,
VirtualHost = virtualHost,
};
//----------------------Pre-Assert---------------------------------
Assert.AreEqual(nameof(RabbitMQSource), rabbitMqSource.ResourceType);
Assert.AreEqual(int.Parse(dependency.Container.Port), rabbitMqSource.Port);
Assert.AreEqual(dependency.Container.IP, rabbitMqSource.HostName);
Assert.AreEqual("test", rabbitMqSource.UserName);
Assert.AreEqual("test", rabbitMqSource.Password);
Assert.AreEqual("/", rabbitMqSource.VirtualHost);
//-------------------------------Act---------------------------------
try
{
using (var rabbitConnection = rabbitMqSource.NewConnection())
{
//-------------------------------Assert------------------------------
Assert.IsTrue(rabbitConnection.IsOpen);
}
}
catch (BrokerUnreachableException e)
{
Assert.Inconclusive(e.Message);
}
}
public StringBuilder Execute(Dictionary <string, StringBuilder> values, IWorkspace theWorkspace)
{
ExecuteMessage msg = new ExecuteMessage();
Dev2JsonSerializer serializer = new Dev2JsonSerializer();
try
{
Dev2Logger.Info("Save RabbitMQ Service Source");
StringBuilder resourceDefinition;
msg.HasError = false;
values.TryGetValue("RabbitMQServiceSource", out resourceDefinition);
RabbitMQServiceSourceDefinition rabbitMQServiceSourceDefinition = serializer.Deserialize <RabbitMQServiceSourceDefinition>(resourceDefinition);
if (rabbitMQServiceSourceDefinition.ResourcePath.EndsWith("\\"))
{
rabbitMQServiceSourceDefinition.ResourcePath = rabbitMQServiceSourceDefinition.ResourcePath.Substring(0, rabbitMQServiceSourceDefinition.ResourcePath.LastIndexOf("\\", StringComparison.Ordinal));
}
RabbitMQSource rabbitMQSource = new RabbitMQSource
{
ResourceID = rabbitMQServiceSourceDefinition.ResourceID,
ResourceName = rabbitMQServiceSourceDefinition.ResourceName,
HostName = rabbitMQServiceSourceDefinition.HostName,
Port = rabbitMQServiceSourceDefinition.Port,
UserName = rabbitMQServiceSourceDefinition.UserName,
Password = rabbitMQServiceSourceDefinition.Password,
VirtualHost = rabbitMQServiceSourceDefinition.VirtualHost
};
ResourceCatalog.Instance.SaveResource(GlobalConstants.ServerWorkspaceID, rabbitMQSource, rabbitMQServiceSourceDefinition.ResourcePath);
}
catch (Exception err)
{
msg.HasError = true;
msg.Message = new StringBuilder(err.Message);
Dev2Logger.Error("Save RabbitMQ Service Source Failed: " + err.Message);
}
return(serializer.SerializeToBuilder(msg));
}
public void RabbitMQSource_Publish_Success()
{
//----------------------Arrange----------------------
var queueSource = new RabbitMQSource();
var queueName = TestQueueNameGenerator.GetName;
var config = new RabbitConfig
{
QueueName = queueName,
Exchange = "",
RoutingKey = queueName,
};
//----------------------Act--------------------------
var message = Guid.NewGuid().ToString();
var data = Encoding.UTF8.GetBytes(message);
var connection = queueSource.NewConnection(config);
try
{
var publisher = connection.NewPublisher(config);
publisher.Publish(data);
using (var testPublishSuccess = new TestPublishSuccess())
{
var sentData = testPublishSuccess.GetSentMessage(config.QueueName);
//------------------------Assert----------------------
Assert.AreEqual(config.Exchange, sentData.Exchange);
Assert.AreEqual(config.RoutingKey, sentData.RoutingKey);
Assert.AreEqual(message, Encoding.UTF8.GetString(sentData.Body));
}
}
finally
{
connection.DeleteQueue(config);
connection.Dispose();
}
}
public void RabbitMQSource_GivenSourceCreateNewConnection_Success()
{
//----------------------Arrange----------------------
var queueSource = new RabbitMQSource();
var queueName = TestQueueNameGenerator.GetName;
var testConsumer = new TestConsumer();
var config = new RabbitConfig
{
QueueName = queueName,
Exchange = "",
RoutingKey = queueName,
};
//----------------------Act--------------------------
using (var connection = queueSource.NewConnection(config))
{
connection.StartConsuming(config, testConsumer);
}
int i = 0;
while (!testConsumer.IsDataReceived)
{
Thread.Sleep(100);
if (i >= 30)
{
break;
}
i++;
}
//----------------------Assert-----------------------
Assert.IsFalse(testConsumer.IsDataReceived);
}
protected override List <string> PerformExecution(Dictionary <string, string> evaluatedValues)
{
_messages = new List <string>();
try
{
RabbitSource = ResourceCatalog.GetResource <RabbitMQSource>(GlobalConstants.ServerWorkspaceID, RabbitMQSourceResourceId);
if (RabbitSource == null || RabbitSource.ResourceType != enSourceType.RabbitMQSource.ToString())
{
return(new List <string> {
ErrorResource.RabbitSourceHasBeenDeleted
});
}
string queueName;
if (!evaluatedValues.TryGetValue("QueueName", out queueName))
{
return(new List <string> {
ErrorResource.RabbitQueueNameRequired
});
}
string prefetch;
if (!evaluatedValues.TryGetValue("Prefetch", out prefetch))
{
prefetch = string.Empty;
}
ConnectionFactory.HostName = RabbitSource.HostName;
ConnectionFactory.Port = RabbitSource.Port;
ConnectionFactory.UserName = RabbitSource.UserName;
ConnectionFactory.Password = RabbitSource.Password;
ConnectionFactory.VirtualHost = RabbitSource.VirtualHost;
using (Connection = ConnectionFactory.CreateConnection())
{
using (Channel = Connection.CreateModel())
{
if (!string.IsNullOrEmpty(TimeOut))
{
_timeOut = int.Parse(TimeOut);
}
_prefetch = string.IsNullOrEmpty(prefetch) ? (ushort)0 : ushort.Parse(prefetch);
if (_prefetch == 0)
{
_prefetch = ushort.MaxValue;
}
Channel.BasicQos(0, _prefetch, Acknowledge);
int msgCount = 0;
if (ReQueue)
{
BasicGetResult response;
try
{
response = Channel.BasicGet(queueName, false);
}
catch (Exception)
{
throw new Exception(string.Format(ErrorResource.RabbitQueueNotFound, queueName));
}
while (response != null && _prefetch > msgCount)
{
_messages.Add(Encoding.Default.GetString(response.Body));
msgCount++;
try
{
response = Channel.BasicGet(queueName, false);
}
catch (Exception)
{
throw new Exception(string.Format(ErrorResource.RabbitQueueNotFound, queueName));
}
}
}
else
{
if (!string.IsNullOrEmpty(TimeOut))
{
Consumer = new QueueingBasicConsumer(Channel);
try
{
Channel.BasicConsume(queueName, false, Consumer);
}
catch (Exception)
{
throw new Exception(string.Format(ErrorResource.RabbitQueueNotFound, queueName));
}
BasicDeliverEventArgs basicDeliverEventArgs;
ulong?tag = null;
while (Consumer.Queue.Dequeue((int)TimeSpan.FromSeconds(_timeOut).TotalMilliseconds, out basicDeliverEventArgs) && _prefetch > msgCount)
{
if (basicDeliverEventArgs == null)
{
_result = string.Format("Empty, timeout: {0} second(s)", _timeOut);
}
else
{
var body = basicDeliverEventArgs.Body;
_messages.Add(Encoding.Default.GetString(body));
tag = basicDeliverEventArgs.DeliveryTag;
}
msgCount++;
}
if (tag.HasValue)
{
Channel.BasicAck(tag.Value, _prefetch != 1);
}
}
else
{
uint messageCount;
try
{
messageCount = Channel.MessageCount(queueName);
}
catch (Exception)
{
messageCount = 0;
}
Consumer = new QueueingBasicConsumer(Channel);
try
{
Channel.BasicConsume(queueName, false, Consumer);
}
catch (Exception)
{
throw new Exception(string.Format(ErrorResource.RabbitQueueNotFound, queueName));
}
ulong?tag = null;
for (int i = 0; i < messageCount && _prefetch > msgCount; i++)
{
var ea = Consumer.Queue.Dequeue();
var body = ea.Body;
_messages.Add(Encoding.Default.GetString(body));
tag = ea.DeliveryTag;
msgCount++;
}
if (tag.HasValue)
{
Channel.BasicAck(tag.Value, _prefetch != 1);
}
else
{
_result = "Empty";
}
}
}
}
}
return(new List <string> {
_result
});
}
catch (Exception ex)
{
Dev2Logger.Error("ConsumeRabbitMQActivity", ex);
throw new Exception(ex.GetAllMessages());
}
}
