public override Exchange Process(Exchange exchange, UriDescriptor endPointDescriptor)
{
var baseApiUri = endPointDescriptor.ComponentPath;
var location = endPointDescriptor.GetUriProperty("location", "");
var resultHeader = endPointDescriptor.GetUriProperty("resultHeader");
var lat = endPointDescriptor.GetUriProperty("lat");
var lon = endPointDescriptor.GetUriProperty("lon");
using (var client = new WebClient())
{
if (!string.IsNullOrEmpty(lat))
client.QueryString.Add("lat", lat);
if (!string.IsNullOrEmpty(lon))
client.QueryString.Add("lon", lon);
var finaUrl = string.Format("{0}?q={1}", baseApiUri, location);
var result = client.DownloadString(finaUrl);
if (!string.IsNullOrEmpty(resultHeader))
exchange.InMessage.SetHeader("resultHeader", result);
else
{
exchange.InMessage.Body = result;
}
}
return exchange;
}
public static void Execute(string uri, Exchange exchange, Route route)
{
uri = SimpleExpression.ResolveSpecifiedUriPart(uri, exchange);
var leafNodeParts = UriDescriptor.Parse(uri, exchange);
EndpointBuilder.HandleFrom(leafNodeParts, route);
}
public override Exchange Process(Exchange exchange, UriDescriptor endPointDescriptor)
{
try
{
var inReverse = endPointDescriptor.GetUriProperty("reverse", false);
var useOut = endPointDescriptor.GetUriProperty("useout", false);
var body = useOut ? exchange.OutMessage.Body.ToString() : exchange.InMessage.Body.ToString();
if (!inReverse)
{
var doc = new XmlDocument();
doc.LoadXml(body);
var jsonText = JsonConvert.SerializeXmlNode(doc);
exchange.InMessage.Body = jsonText;
}
else
{
var doc = JsonConvert.DeserializeXmlNode(body);
exchange.InMessage.Body = doc.InnerXml;
}
Camel.TryLog(exchange, "processor", endPointDescriptor.ComponentName);
}
catch (Exception exception)
{
}
return base.Process(exchange, endPointDescriptor);
}
public override Exchange Process(Exchange exchange, UriDescriptor endPointDescriptor)
{
try
{
var method = endPointDescriptor.GetUriProperty("method");
var objectTypePath = endPointDescriptor.ComponentPath;
var objectType = Type.GetType(objectTypePath);
if (objectType != null)
{
var objectInstance = Activator.CreateInstance(objectType, null);
if (!string.IsNullOrEmpty(method))
{
//process normalizer method
var methodMember = objectInstance.GetType()
.GetMethod(method, BindingFlags.IgnoreCase | BindingFlags.Public | BindingFlags.Instance);
methodMember.Invoke(objectInstance, null);
}
}
}
catch (Exception exception)
{
}
return base.Process(exchange, endPointDescriptor);
}
public static void Enrich(XElement step, Exchange exchange, Route routeObj)
{
try
{
var uri = step.Attribute("uri");
var strategyref = step.Attribute("strategyref");
if (uri == null || strategyref == null)
{
return;
}
var uriInfo = UriDescriptor.Parse(uri.Value, exchange);
var clonedExchange = exchange.CloneExchange();
EndpointBuilder.HandleTo(uriInfo, clonedExchange, routeObj);
//fetch strategy
var stragegyObj = SynapseContext.Registry[strategyref.Value] as AggregationStrategy;
if (stragegyObj != null)
{
stragegyObj.Aggregate(exchange, clonedExchange);
}
}
catch (Exception exc)
{
}
}
public override Exchange Process(Exchange exchange, UriDescriptor endPointDescriptor)
{
try
{
var protocol = endPointDescriptor.GetUriProperty<string>("protocol");
switch (protocol)
{
case "smtp":
Task.Factory.StartNew(() => SendMail(endPointDescriptor, exchange));
break;
case "imap":
break;
}
}
catch (AggregateException aggregateException)
{
Console.WriteLine("aggr-error sending mail: {0}", aggregateException.Message);
}
catch (Exception exception)
{
Console.WriteLine("error sending mail: {0}", exception.Message);
}
return base.Process(exchange, endPointDescriptor);
}
public override Exchange Process(Exchange exchange, UriDescriptor endPointDescriptor)
{
try
{
var hostname = endPointDescriptor.GetUriProperty("hostname", "localhost");
var queue = endPointDescriptor.GetUriProperty("queue", "systemQueue");
var port = endPointDescriptor.GetUriProperty("port", 5672);
var channel = GetChannel(string.Format("{0}::{1}::{2}", hostname, port, queue), queue, hostname);
channel.QueueDeclare(queue: queue,
durable: true,
exclusive: false,
autoDelete: false,
arguments: null);
var msg = exchange.InMessage.Body.ToString();
var body = Encoding.UTF8.GetBytes(msg);
//send
channel.BasicPublish(exchange: "",
routingKey: queue,
basicProperties: null,
body: body);
}
catch (Exception exception)
{
var msg = exception.Message;
}
return(exchange);
}
public override Exchange Process(Exchange exchange, UriDescriptor endPointDescriptor)
{
try
{
var host = endPointDescriptor.GetUriProperty("host");
var isBodyXml = endPointDescriptor.GetUriProperty<bool>("isBodyXml");
var database = endPointDescriptor.GetUriProperty("database");
var collection = endPointDescriptor.GetUriProperty("collection");
var createCollection = endPointDescriptor.GetUriProperty<bool>("createCollection");
var operation = endPointDescriptor.GetUriProperty<OperationType>("operation");
var client = new MongoClient("mongodb://" + host);
var db = client.GetServer().GetDatabase(database);
if (!db.CollectionExists(collection) && createCollection)
db.CreateCollection(collection);
var bson = exchange.InMessage.Body.ToString();
if (isBodyXml)
{
var doc = new XmlDocument();
doc.LoadXml(exchange.InMessage.Body.ToString());
bson = JsonConvert.SerializeXmlNode(doc);
}
var bsonDoc = BsonDocument.Parse(bson);
ServeOperation(db, exchange, endPointDescriptor, bsonDoc, operation, collection);
}
catch (Exception exception)
{
Console.WriteLine("{0}-{1}", exception.Message, exception.StackTrace);
}
return exchange;
}
public override Exchange Process(Exchange exchange, UriDescriptor endPointDescriptor)
{
try
{
Camel.TryLog(exchange, "provider", endPointDescriptor.ComponentName);
var dbHost = endPointDescriptor.ComponentPath;
var port = endPointDescriptor.GetUriProperty<int>("port");
var couchDbDatabase = exchange.InMessage.GetHeader("CouchDbDatabase");
var createDb = endPointDescriptor.GetUriProperty<bool>("createDb");
var document = exchange.InMessage.Body;
var dbUrl = string.Format("http://{0}:{1}", dbHost, port);
var conn = new Connection(new Uri(dbUrl));
if (createDb && !conn.ListDatabases().Contains(couchDbDatabase))
{
conn.CreateDatabase(couchDbDatabase.ToString());
}
}
catch (Exception exception)
{
}
return base.Process(exchange, endPointDescriptor);
}
/// <summary>
/// ProcessRouteInformation From Method
/// </summary>
/// <param name="leafDescriptor"></param>
/// <param name="route"></param>
public static void HandleFrom(UriDescriptor leafDescriptor, Route route, Exchange exchangeData = null)
{
try
{
//init endpoint
DefaultEndpoint endPoint;
if (Camel.EnPointCollection.TryGetValue(leafDescriptor.FullUri, out endPoint))
{
}
else
{
var execAssembly = Assembly.GetExecutingAssembly();
var types = execAssembly.GetTypes();
foreach (var namespaceToCheck in PermissibleNamespaces)
{
var typeData =
types.FirstOrDefault(
c =>
c.FullName.Equals(
string.Format("{0}.{1}.{2}", namespaceToCheck, leafDescriptor.ComponentName,
leafDescriptor.ComponentName),
StringComparison.InvariantCultureIgnoreCase) ||
c.FullName.Equals(
string.Format("{0}.{1}.{2}EndPoint", namespaceToCheck,
leafDescriptor.ComponentName, leafDescriptor.ComponentName),
StringComparison.InvariantCultureIgnoreCase));
if (typeData == null)
continue;
endPoint = (DefaultEndpoint) Activator.CreateInstance(typeData, leafDescriptor.FullUri, route);
Camel.EnPointCollection.TryAdd(leafDescriptor.FullUri, endPoint);
break;
}
}
if (endPoint != null)
{
if (exchangeData == null)
endPoint.Start();
else
{
endPoint.StartWithExistingExchange(exchangeData);
}
}
else
throw new AppCoreException("end-point not found: " + leafDescriptor.ComponentName);
}
catch (AggregateException exception)
{
}
catch (Exception exception)
{
throw new AppCoreException("error handling [from-tag] :" + exception.Message, exception);
}
}
public override Exchange Process(Exchange exchange, UriDescriptor endPointDescriptor)
{
LogStack.Enqueue(new UriExchange { Exchange = exchange, UriDescriptor = endPointDescriptor });
if (LogTask == null)
LogTask = System.Threading.Tasks.Task.Factory.StartNew(ProcessLogQueue);
return exchange;
}
public IConnection CreateConnection(UriDescriptor endPointDescriptor)
{
if (_connection != null)
return _connection;
var path = endPointDescriptor.ComponentPath;
var factory = new ConnectionFactory(string.Format("tcp://{0}/", path));
var connection = factory.CreateConnection();
return _connection = connection;
}
public override Exchange Process(Exchange exchange, UriDescriptor endPointDescriptor)
{
var path = endPointDescriptor.ComponentPath;
var route = Camel.GetRouteBy(path);
if (route != null)
route.CurrentRouteStep.ProcessChannel(exchange);
return exchange;
}
/// <summary>
/// Process
/// </summary>
/// <param name="exchange"></param>
/// <param name="endPointDescriptor"></param>
/// <returns></returns>
public override Exchange Process(Exchange exchange, UriDescriptor endPointDescriptor)
{
try
{
if (exchange.InMessage.Body == null || exchange.InMessage.Body.ToString() == string.Empty)
{
return(exchange);
}
//can create dir
var createOnMissingDir = endPointDescriptor.GetUriProperty <bool>("create");
//create dir if not found
if (!Directory.Exists(endPointDescriptor.ComponentPath))
{
if (createOnMissingDir)
{
Directory.CreateDirectory(endPointDescriptor.ComponentPath);
}
else
{
return(exchange);
}
}
//get details.
var filePath = exchange.InMessage.GetHeader <string>("filePath") ?? endPointDescriptor.ComponentPath;
var fileExtension = endPointDescriptor.GetUriProperty <string>("fileExtension");
//change_file_path
var originalExt = Path.GetExtension(filePath);
filePath = Path.ChangeExtension(filePath, fileExtension ?? originalExt);
var newExt = Path.GetExtension(filePath);
//new path
var fileNameWithExt = Path.GetFileName(filePath);
if (fileNameWithExt != null)
{
filePath = Path.Combine(endPointDescriptor.ComponentPath, fileNameWithExt);
}
filePath = Path.ChangeExtension(filePath, string.Format("{0}{1}", DateTime.Now.Ticks, newExt));
//write
File.AppendAllText(filePath, exchange.InMessage.Body.ToString());
}
catch (Exception exception)
{
var msg = exception.Message;
}
//done
return(exchange);
}
public override Exchange Process(Exchange exchange, UriDescriptor uriDescriptor)
{
try
{
var showOut = uriDescriptor.GetUriProperty("show-out", false);
var filePathToLogTo = uriDescriptor.GetUriProperty("file");
var additionalMessage = uriDescriptor.GetUriProperty("message", "");
//in data
var inHeaderBuilder = new StringBuilder();
exchange.InMessage.HeaderCollection.ToList().ForEach(c => inHeaderBuilder.AppendFormat("{0}='{1}', ", c.Key, c.Value.ToString()));
var propertyBuilder = new StringBuilder();
exchange.PropertyCollection.ToList().ForEach(c => propertyBuilder.AppendFormat("{0}='{1}',", c.Key, c.Value.ToString()));
var inBody = exchange.InMessage.Body.ToString();
var msg = string.Format("Exchange: Id: {0}, MEP={5}. >> Route: ID({1}), Properties [{3}], In Message: [Headers: {2} Body: {4}]",
exchange.ExchangeId, exchange.Route.RouteId, inHeaderBuilder, propertyBuilder, inBody, exchange.MepPattern);
//out data
if (exchange.MepPattern == Exchange.Mep.InOut)
{
var outHeaderBuilder = new StringBuilder();
exchange.OutMessage.HeaderCollection.ToList().ForEach(c => outHeaderBuilder.AppendFormat("{0}='{1}', ", c.Key, c.Value.ToString()));
var outBody = exchange.OutMessage.Body.ToString();
msg = string.Format("{0}, Out Message: [Headers: {1} Body: {2}]", msg, outHeaderBuilder, outBody);
}
var errors = exchange.DequeueAllErrors;
if (errors.Count > 0)
{
var errorListing = new StringBuilder();
errors.ForEach(c => errorListing.AppendFormat("[ error-message?: {0}, any-stack-trace?: {1} ]", c.Message, c.StackTrace));
msg = string.Format("{0}, {1}", msg, errorListing);
}
var starTime = DateTime.Now;
if (!string.IsNullOrEmpty(filePathToLogTo))
Log(filePathToLogTo, msg, uriDescriptor);
var interval = DateTime.Now - starTime;
return exchange;
}
catch (AggregateException exception)
{
}
catch (Exception exception)
{
}
return exchange;
}
public override Exchange Process(Exchange exchange, UriDescriptor endPointDescriptor)
{
var fileData = exchange.OutMessage.Body != null ? exchange.OutMessage.Body.ToString() : "";
var fileName = endPointDescriptor.ComponentPath;
if (!string.IsNullOrEmpty(fileData) && !string.IsNullOrEmpty(fileName))
File.AppendAllText(fileName, fileData);
Camel.TryLog(exchange, "provider", endPointDescriptor.ComponentName);
return exchange;
}
private static void Tap(Exchange exchange, string path, Route route)
{
try
{
var leafNodeParts = UriDescriptor.Parse(path, exchange);
EndpointBuilder.HandleTo(leafNodeParts, exchange, route);
}
catch (Exception exception)
{
Console.WriteLine(exception.Message);
}
}
public override Exchange Process(Exchange exchange, UriDescriptor endPointDescriptor)
{
Route route;
if (!Camel.RouteCollection.TryGetValue(endPointDescriptor.ComponentPath, out route))
return exchange;
Camel.TryLog(exchange, "producer", endPointDescriptor.ComponentName);
exchange.Route = route;
SedaDriver.SedaQueue.TryAdd(endPointDescriptor, exchange);
return exchange;
}
public override Exchange Process(Exchange exchange, UriDescriptor endPointDescriptor)
{
var path = endPointDescriptor.ComponentPath;
var route = SynapseContext.GetRouteBy(path);
if (route != null)
{
route.CurrentRouteStep.ProcessChannel(exchange);
}
return(exchange);
}
public override Exchange Process(Exchange exchange, UriDescriptor endPointDescriptor)
{
try
{
var port = endPointDescriptor.GetUriProperty("port", 7000, exchange);
var receivetimeout = endPointDescriptor.GetUriProperty("receivetimeout", 10000, exchange);
var sendtimeout = endPointDescriptor.GetUriProperty("sendtimeout", 5000, exchange);
var ip = endPointDescriptor.ComponentPath;
var client = new TcpClient();
client.Connect(ip, port);
if (client.Connected)
{
var bodyMsg = exchange.InMessage.Body.ToString();
var buffer = Encoding.ASCII.GetBytes(bodyMsg);
Camel.TryLog(exchange, "producer", endPointDescriptor.ComponentName);
client.Client.ReceiveTimeout = receivetimeout;
client.Client.SendTimeout = sendtimeout;
client.Client.Send(buffer);
using (var networkStream = client.GetStream())
{
if (networkStream.CanRead)
{
// Buffer to store the response bytes.
var readBuffer = new byte[client.ReceiveBufferSize];
using (var writer = new MemoryStream())
{
do
{
var numberOfBytesRead = networkStream.Read(readBuffer, 0, readBuffer.Length);
if (numberOfBytesRead <= 0)
{
break;
}
writer.Write(readBuffer, 0, numberOfBytesRead);
} while (networkStream.DataAvailable);
exchange.InMessage.Body = Encoding.UTF8.GetString(writer.ToArray());
}
}
}
}
}
catch (System.Exception exception)
{
Console.WriteLine(exception.StackTrace);
}
return exchange;
}
public static void Execute(string delay, Exchange exchange, UriDescriptor uriDescriptor)
{
var ndxDelay = 1000;
try
{
ndxDelay = Convert.ToInt32(delay);
}
catch (Exception exception)
{
}
Thread.Sleep(ndxDelay);
}
/// <summary>
///
/// </summary>
/// <param name="delay"></param>
/// <param name="exchange"></param>
/// <param name="uriDescriptor"></param>
public static void Execute(string delay, Exchange exchange, UriDescriptor uriDescriptor)
{
var ndxDelay = 1000;
try
{
ndxDelay = Convert.ToInt32(delay);
}
catch (AggregateException exception)
{
}
catch (Exception exception)
{
}
Thread.Sleep(ndxDelay);
}
public override Exchange Process(Exchange exchange, UriDescriptor uriInformation)
{
var name = uriInformation.ComponentPath;
var role = uriInformation.GetUriProperty("role");
var sharedKey = uriInformation.GetUriProperty("sharedKey");
var claims = new Dictionary<string, string>
{
{"name", name},
{"role", role},
};
var token = JWT.JsonWebToken.Encode(claims, sharedKey, JWT.JwtHashAlgorithm.HS256);
exchange.InMessage.SetHeader(uriInformation.ComponentPath, token);
Camel.TryLog(exchange, "producer", uriInformation.ComponentName);
return exchange;
}
public IConnection CreateConnection(UriDescriptor endPointDescriptor)
{
if (_connection != null)
return _connection;
try
{
var path = endPointDescriptor.ComponentPath;
var factory = new ConnectionFactory(string.Format("activemq:tcp://{0}/", path));
var connection = factory.CreateConnection();
connection.Start();
return _connection = connection;
}
catch (Exception)
{
return null;
}
}
private static void SendMail(UriDescriptor endPointDescriptor, Exchange exchange)
{
try
{
var toAddress = endPointDescriptor.GetUriProperty("to");
var from = endPointDescriptor.GetUriProperty("from");
var port = endPointDescriptor.GetUriProperty<int>("port");
var host = endPointDescriptor.ComponentPath;
var subject = endPointDescriptor.GetUriProperty<string>("subject");
var body = endPointDescriptor.GetUriProperty<string>("body");
var username = endPointDescriptor.GetUriProperty<string>("username");
var password = endPointDescriptor.GetUriProperty<string>("password");
var mail = new MailMessage();
var client = new SmtpClient
{
Port = port,
DeliveryMethod = SmtpDeliveryMethod.Network,
Host = host,
};
if (!string.IsNullOrEmpty(username) &&
!string.IsNullOrEmpty(password))
{
client.Credentials = new NetworkCredential(username, password);
}
mail.To.Add(new MailAddress(toAddress));
mail.From = new MailAddress(@from);
mail.IsBodyHtml = true;
mail.Body = exchange.InMessage.Body.ToString();
mail.Subject = subject;
Camel.TryLog(exchange, "producer", endPointDescriptor.ComponentName);
client.Send(mail);
}
catch (Exception exception)
{
}
}
private static void ServeOperation(MongoDatabase db, Exchange exchange,
UriDescriptor endPointDescriptor,
BsonDocument doc, OperationType operation, string collection)
{
switch (operation)
{
case OperationType.Insert:
db.GetCollection(collection).Insert(doc);
break;
case OperationType.FetchById:
db.GetCollection(collection).FindOneById("");
break;
case OperationType.FetchAll:
db.GetCollection(collection).FindAll();
break;
case OperationType.Remove:
db.GetCollection(collection).Remove(null);
break;
}
}
public override Exchange Process(Exchange exchange, UriDescriptor descriptor)
{
Camel.TryLog(exchange, "producer", descriptor.ComponentName);
var action = descriptor.ComponentPath ?? "add";
try
{
switch (action)
{
case "add":
var coll = UriDescriptor.BuildKeyValueListWithEquality(descriptor.ComponentQueryPath);
break;
default:
break;
}
}
catch
{
}
return exchange;
}
public override Exchange Process(Exchange exchange, UriDescriptor endPointDescriptor)
{
try
{
var connection = CreateConnection(endPointDescriptor);
var queue = endPointDescriptor.GetUriProperty("queue", "test_queue." + DateTime.Now.Ticks);
var requestTimeOut = endPointDescriptor.GetUriProperty("timeout", new TimeSpan(0, 10, 0));
using (var session = connection.CreateSession())
{
IDestination temporaryDestination = session.CreateTemporaryQueue();
var topic = session.GetQueue(queue);
var producer = session.CreateProducer(topic);
producer.RequestTimeout = requestTimeOut;
//create message
var messageSer = JsonConvert.SerializeObject(exchange);
var message = session.CreateTextMessage(messageSer);
message.NMSCorrelationID = exchange.ExchangeId.ToString();
message.NMSReplyTo = temporaryDestination;
producer.Send(message);
}
}
catch (AggregateException)
{
}
catch (Exception exception)
{
Console.WriteLine("{0}-{1}", exception.Message, exception.StackTrace);
exchange.SetException(new Exception("error connecting to amq", exception));
}
return exchange;
}
public FileProducer(UriDescriptor uriInformation, Route route)
: base(uriInformation, route)
{
}
public MinaProcessor(UriDescriptor uriInformation, Route route)
: base(uriInformation, route)
{
}
public virtual Exchange Process(Exchange exchange, UriDescriptor endPointDescriptor)
{
return(null);
}
public DirectProducer(UriDescriptor uriInformation, Route route) : base(uriInformation, route)
{
}
public override void Send(Exchange exchange, UriDescriptor endPointDescriptor)
{
var producer = CreateProducer();
producer.Process(exchange, endPointDescriptor);
}
private void Log(string filePathToLogTo, string defaultStr, UriDescriptor descriptor)
{
lock (_locker)
{
var existingRepo = LogManager.GetAllRepositories().FirstOrDefault(c => c.Name == "core.app");
if (existingRepo == null)
{
var repository = LogManager.CreateRepository("core.app");
var fileAppender = new RollingFileAppender
{
MaxFileSize = 10000000,
MaxSizeRollBackups = 10,
RollingStyle = RollingFileAppender.RollingMode.Size,
AppendToFile = true,
File = filePathToLogTo,
Threshold = new Level(0, "DEBUG"),
LockingModel = new FileAppender.MinimalLock()
};
var pl = new PatternLayout { ConversionPattern = "%utcdate,%message%newline" };
pl.ActivateOptions();
fileAppender.Layout = pl;
fileAppender.ActivateOptions();
BasicConfigurator.Configure(repository, fileAppender);
log = LogManager.GetLogger(typeof(LogProcessor));
var hierarchy = (Hierarchy)LogManager.GetRepository();
hierarchy.Root.AddAppender(fileAppender);
hierarchy.Configured = true;
}
else
{
var appender = (RollingFileAppender)LogManager.GetRepository().GetAppenders().FirstOrDefault(c => c is RollingFileAppender);
if (appender != null)
{
appender.File = filePathToLogTo;
appender.ActivateOptions();
}
}
}
log.Debug(defaultStr);
}
public OpenWeatherProducer(UriDescriptor uriInformation, Route route)
: base(uriInformation, route)
{
}
/// <summary>
/// Class constructor
/// </summary>
/// <param name="uriInformation"></param>
/// <param name="route"></param>
protected ProcessorBase(UriDescriptor uriInformation, Route route)
{
UriInformation = uriInformation;
Route = route;
}
public XmlToJsonProducer(UriDescriptor uriInformation, Route route)
: base(uriInformation, route)
{
}
public FileProcessor(UriDescriptor uriInformation, Route route)
: base(uriInformation, route)
{
}
protected DefaultProcessor(UriDescriptor uriInformation, Route route)
{
UriInformation = uriInformation;
Route = route;
}
public RabbitMqProducer(UriDescriptor uriInformation, Route route)
: base(uriInformation, route)
{
}
public EndpointBase(string uri, Route route)
{
Route = route;
Uri = uri;
UriDescriptor = UriDescriptor.Parse(uri);
}
public ProducerBase(UriDescriptor uriInformation, Route route)
{
_uriInformation = uriInformation;
_route = route;
}
public DefaultProducer(UriDescriptor uriInformation, Route route)
{
_uriInformation = uriInformation;
_route = route;
}
public override void Send(Exchange exchange, UriDescriptor endPointDescriptor)
{
var producer = CreateProducer();
producer.Process(exchange, endPointDescriptor);
}
public virtual Exchange Process(Exchange exchange, UriDescriptor endPointDescriptor)
{
return null;
}
public virtual void Send(Exchange exchange, UriDescriptor endPointDescriptor)
{
}
public static void Execute(string uri, Exchange exchange, Route route)
{
var leafNodeParts = UriDescriptor.Parse(uri, exchange);
EndpointBuilder.HandleTo(leafNodeParts, exchange, route);
}
