public SubscriptionClient(IServiceBus bus, SubscriptionRouter router, Uri subscriptionServiceUri,
TimeSpan startTimeout)
{
_bus = bus;
_router = router;
_subscriptionServiceUri = subscriptionServiceUri;
_startTimeout = startTimeout;
_network = router.Network;
if (_log.IsDebugEnabled)
_log.DebugFormat("Starting SubscriptionClient using {0}", subscriptionServiceUri);
VerifyClientAndServiceNotOnSameEndpoint(bus);
_ready.Reset();
var consumerInstance = new SubscriptionMessageConsumer(_router, _network);
_unsubscribeAction = _bus.ControlBus.SubscribeInstance(consumerInstance);
_unsubscribeAction += _bus.ControlBus.SubscribeContextHandler<SubscriptionRefresh>(Consume);
_subscriptionEndpoint = _bus.GetEndpoint(subscriptionServiceUri);
_producer = new SubscriptionServiceMessageProducer(router, _subscriptionEndpoint);
WaitForSubscriptionServiceResponse();
}
public void SendMessage(WireSendingMessage message, IEndpoint endpoint)
{
TransportPipe pipe;
var customEndpoint = (CustomTcpEndpoint) endpoint;
if (!_endpointToPipe.TryGetValue(customEndpoint, out pipe))
{
pipe = new TcpTransportPipeMultiThread(3000000,
HighWaterMarkBehavior.Block,
customEndpoint.EndPoint,
_transport);
_endpointToPipe.Add(customEndpoint, pipe);
}
var wait = default(SpinWait);
var sent = false;
bool first = true;
var buffer = _serializer.Serialize(message.MessageData);
do
{
sent = pipe.Send(new ArraySegment<byte>(buffer, 0, buffer.Length), true);
if (!first)
wait.SpinOnce();
else
first = false;
} while (!sent && wait.Count < 1000);
if (!sent) //peer is disconnected (or underwater from too many message), raise some event?
{
Console.WriteLine("AAAAG");
_logger.Info(string.Format("disconnect of endpoint {0}", customEndpoint.EndPoint));
EndpointDisconnected(endpoint);
pipe.Dispose();
_endpointToPipe.Remove(customEndpoint);
}
}
public override void ProcessMessage(IEndpoint endpoint, byte[] data)
{
List<byte> package = new List<byte>();
if (_client == null)
{
_client = new TcpClient();
_client.Connect(_options.Endpoint);
if (_options.SohDelimiters.Length > 0)
{
package.AddRange(_options.SohDelimiters);
}
}
//TODO: If options mandate delimters, write STX and ETX here
if (_options.StxDelimiters.Length > 0)
{
package.AddRange(_options.StxDelimiters);
}
package.AddRange(data);
if (_options.EtxDelimiters.Length > 0)
{
package.AddRange(_options.EtxDelimiters);
}
Write(package.ToArray());
if (!_options.KeepConnectionOpen)
{
CloseConnection();
}
}
public void SetUp()
{
endpoint = A.Fake<IEndpoint>();
applicationEndpoints = new List<IEndpoint> { endpoint };
findNextRequestChainPart = A.Fake<IFindNextRequestChainPart>();
requestGraph = new RequestGraph(applicationEndpoints, findNextRequestChainPart);
}
public IClient Create(IEndpoint endpoint, IClientPool ownerPool)
{
TSocket socket = null;
TTransport transport = null;
if (endpoint.Timeout == 0)
{
socket = new TSocket(endpoint.Address, endpoint.Port);
}
else
{
socket = new TSocket(endpoint.Address, endpoint.Port, endpoint.Timeout);
}
TcpClient tcpClient = socket.TcpClient;
if (this.isBufferSizeSet)
{
transport = new TBufferedTransport(socket, this.bufferSize);
}
else
{
transport = new TBufferedTransport(socket);
}
TProtocol protocol = new TBinaryProtocol(transport);
CassandraClient cassandraClient = new CassandraClient(protocol);
IClient client = new DefaultClient() {
CassandraClient = cassandraClient,
Endpoint = endpoint,
OwnerPool = ownerPool,
TcpClient = tcpClient,
Created = DateTime.Now
};
return client;
}
public override void Bind(IEndpoint endpoint)
{
// TODO: ClearOldHeaders
Open();
safeChannel.Channel.QueueBind(endpoint.Name, name, endpoint.RoutingKey, endpoint.RoutingHeaders);
Close();
}
public IClient Create(IEndpoint endpoint, IClientPool ownerPool)
{
TSocket socket = null;
if (endpoint.Timeout == 0)
{
socket = new TSocket(endpoint.Address, endpoint.Port);
}
else
{
socket = new TSocket(endpoint.Address, endpoint.Port, endpoint.Timeout);
}
TcpClient tcpClient = socket.TcpClient;
TProtocol protocol = new TBinaryProtocol(socket);
CassandraClient cassandraClient = new CassandraClient(protocol);
IClient client = new DefaultClient()
{
CassandraClient = cassandraClient,
Endpoint = endpoint,
OwnerPool = ownerPool,
TcpClient = tcpClient,
Created = DateTime.Now
};
return client;
}
public string DispatchAction(IEndpoint endpoint)
{
switch (endpoint.ActionName)
{
case "RegisterUser":
return this.ProcessRegisterUserCommand(endpoint.Parameters);
case "LoginUser":
return this.ProcessLoginUserCommand(endpoint.Parameters);
case "LogoutUser":
return this.ProcessLogoutUserCommand();
case "CreateIssue":
return this.ProcessCreateIssueCommand(endpoint.Parameters);
case "RemoveIssue":
return this.ProcessRemoveIssueCommand(endpoint.Parameters);
case "AddComment":
return this.ProcessAddCommentCommand(endpoint.Parameters);
case "MyIssues":
return this.ProcessMyIssuesCommand();
case "MyComments":
return this.ProcessMyCommentsCommand();
case "Search":
return this.ProcessSearchCommand(endpoint.Parameters);
default:
return string.Format(Messages.IvalidActionWithName, endpoint.ActionName);
}
}
public ViewEngineResult FindView(IEndpoint endpoint)
{
var templates = filterViewsCollection.FindTemplates(endpoint, FindAllTemplates()).ToList();
if (templates.Count < 1) return null;
if (templates.Count > 1)
throw new UWebSparkException(
string.Format(
"More then one template was found for endpoint '{0}.{1}'.\nThe following templates were found: {2}",
endpoint.HandlerType.Name, endpoint.Method.Name,
string.Join(", ", templates.Select(x => x.Name))));
var template = templates.Single();
var descriptor = descriptorBuilder.BuildDescriptor(template, true, null, null);
var sparkViewEntry = engine.CreateEntry(descriptor);
var view = sparkViewEntry.CreateInstance() as UWebSparkView;
if (view != null) view.ResolveDependencies = resolveDependencies;
return new ViewEngineResult(view);
}
private static object[] MapParameters(IEndpoint executionEndpoint, MethodInfo action)
{
var methodParams = action.GetParameters();
var result = new object[methodParams.Length];
int pos = 0;
foreach (var param in methodParams)
{
object value = null;
if (param.ParameterType == typeof(DateTime))
{
value = DateTime.ParseExact(
executionEndpoint.Parameters[param.Name],
Constants.DateFormat,
CultureInfo.InvariantCulture);
}
else
{
value = Convert.ChangeType(
executionEndpoint.Parameters[param.Name],
param.ParameterType);
}
result[pos++] = value;
}
return result;
}
public ServiceHeartbeatMonitor(IEndpoint publisherEndpoint, IEndpoint subscriberEndpoint, MessageFormatType expectedMessageFormat)
: this(publisherEndpoint,
subscriberEndpoint,
new SubscriptionsMsmqChannel(subscriberEndpoint, expectedMessageFormat),
new ServiceHeartbeatMsmqChannel(subscriberEndpoint, expectedMessageFormat))
{
}
public string DispatchAction(IEndpoint endpoint)
{
switch (endpoint.ActionName)
{
case "RegisterUser":
return this.tracker.RegisterUser(
endpoint.Parameters["username"],
endpoint.Parameters["password"],
endpoint.Parameters["confirmPassword"]);
case "LoginUser":
return this.tracker.LoginUser(endpoint.Parameters["username"], endpoint.Parameters["password"]);
case "CreateIssue":
return this.tracker.CreateIssue(
endpoint.Parameters["title"],
endpoint.Parameters["description"],
(IssuePriority)Enum.Parse(typeof(IssuePriority), endpoint.Parameters["priority"], true),
endpoint.Parameters["tags"].Split('|'));
case "RemoveIssue":
return this.tracker.RemoveIssue(int.Parse(endpoint.Parameters["id"]));
case "LogoutUser":
return this.tracker.LogoutUser();
case "AddComment":
return this.tracker.AddComment(int.Parse(endpoint.Parameters["id"]), endpoint.Parameters["text"]);
case "MyIssues":
return this.tracker.GetMyIssues();
case "MyComments":
return this.tracker.GetMyComments();
case "Search":
return this.tracker.SearchForIssues(endpoint.Parameters["tags"].Split('|'));
default:
return string.Format("Invalid action: {0}", endpoint.ActionName);
}
}
/// <summary>
/// Adds a named endpoint to the collection
/// </summary>
/// <param name="endpointName">The name of the endpoint</param>
/// <param name="endpoint">The endpoint</param>
/// <exception cref="ArgumentNullException">Thrown if <paramref name="endpointName"/>
/// or <paramref name="endpoint"/> are <c>null</c></exception>
/// <exception cref="EndpointAlreadyExistsException">Thrown if there is already an
/// endpoint with the specified <paramref name="endpointName"/></exception>
public void Add(EndpointName endpointName, IEndpoint endpoint)
{
if (endpointName == null) throw new ArgumentNullException("endpointName");
if (endpoint == null) throw new ArgumentNullException("endpoint");
if (_endpoints.ContainsKey(endpointName)) throw new EndpointAlreadyExistsException(endpointName);
_endpoints[endpointName] = endpoint;
}
private static object[] MapParameters(IEndpoint executionEndpoint, MethodInfo action)
{
var parameters = action
.GetParameters()
.Select<ParameterInfo, object>(p =>
{
if (p.ParameterType == typeof(int))
{
return int.Parse(executionEndpoint.Parameters[p.Name]);
}
else if (p.ParameterType == typeof(DateTime))
{
return DateTime.ParseExact(executionEndpoint.Parameters[p.Name], Constants.DateFormat, CultureInfo.InvariantCulture);
}
else if (p.ParameterType == typeof(decimal))
{
return decimal.Parse(executionEndpoint.Parameters[p.Name]);
}
else
{
return executionEndpoint.Parameters[p.Name];
}
})
.ToArray();
return parameters;
}
public RedirectResult GetUrlToRedirectTo(object result, IEndpoint endpoint)
{
var redirectable = (IRedirectable) result;
var redirectResult = redirectable.RedirectTo();
return new RedirectResult(redirectResult.GetUrl(urlBuilder), redirectable.Permanent);
}
public ShadowMessageCommand(MessageWireData message, PeerId primaryRecipient, bool primaryWasOnline, IEndpoint targetEndpoint)
{
Message = message;
PrimaryRecipient = primaryRecipient;
PrimaryWasOnline = primaryWasOnline;
TargetEndpoint = targetEndpoint;
}
public IMessageTopology Build(IEndpoint endpoint)
{
var topology = new MessageTopology();
topology.PublishExchange = topology.DefineExchange(endpoint.Name, ExchangeType.Topic);
return topology;
}
public CompletionAcknowledgementMessage(Guid messageId, string messageType, bool processingSuccessful, IEndpoint endpoint)
{
MessageId = messageId;
ProcessingSuccessful = processingSuccessful;
Endpoint = endpoint;
MessageType = messageType;
}
public MessageSubscription(Type messageType, PeerId peer, IEndpoint endpoint, ISubscriptionFilter subscriptionFilter, ReliabilityLevel reliabilityLevel)
{
MessageType = messageType;
Peer = peer;
Endpoint = endpoint;
SubscriptionFilter = (subscriptionFilter);
ReliabilityLevel = reliabilityLevel;
}
public void Render(object result, IEndpoint endpoint, IOutputWriter outputWriter, IRequest request)
{
var renderer = GetMatching(result, endpoint, request).FirstOrDefault();
if(renderer == null) return;
renderer.Render(result, endpoint, outputWriter);
}
public void Save(IEndpoint endpoint)
{
var key = endpoint.Name.ToLower();
if (Endpoints.ContainsKey(key))
Endpoints[key] = endpoint;
else
Endpoints.Add(key, endpoint);
}
public PipelineConsumerWork(IMessageProcessor processor, IEndpoint endpoint, ISerializer serializer, MessageThreshold messageThreshold, IEndpointCircuitBreaker circuitBreaker)
{
this.endpoint = endpoint;
this.processor = processor;
this.circuitBreaker = circuitBreaker;
this.serializer = serializer;
this.messageThreshold = messageThreshold ?? new MessageThreshold();
}
public AuthenticateEndpoint(IEndpoint endpoint, IAuthenticationRuleCollection authenticationRuleCollection, IAuthentication authentication,
IOutputWriter outputWriter)
{
this.endpoint = endpoint;
this.authenticationRuleCollection = authenticationRuleCollection;
this.authentication = authentication;
this.outputWriter = outputWriter;
}
public RenderEndpointResult(IRenderEndpointResultCollection renderEndpointResultCollection, IEndpoint endpoint, IOutputWriter outputWriter,
IRequest currentRequest, IRequestBinder requestBinder)
{
this.renderEndpointResultCollection = renderEndpointResultCollection;
this.endpoint = endpoint;
this.outputWriter = outputWriter;
this.currentRequest = currentRequest;
this.requestBinder = requestBinder;
}
public override void ProcessMessage(IEndpoint endpoint, byte[] data)
{
using (StreamWriter writer = new StreamWriter(_filePath, _append, _encoding))
{
writer.Write(Encoding.UTF8.GetString(data));
writer.Close();
MessageSent.Set();
}
}
public void Reinitialize(string messageType, PeerId peerId, Guid messageIdentity, IEndpoint endpoint, byte[] data, int? sequenceNumber)
{
PeerId = peerId;
MessageIdentity = messageIdentity;
MessageType = messageType;
Data = data;
SequenceNumber = sequenceNumber;
Endpoint = endpoint;
}
public ServiceNodePeer(IEndpoint controlEndpoint, IEndpoint serviceEndpoint, int pingTimeout)
{
ControlEndpoint = controlEndpoint;
ServiceEndpoint = serviceEndpoint;
_pingTimeout = pingTimeout;
_cancel = new CancellationTokenSource();
_composer = new TaskComposer<Peer>(_cancel.Token);
}
public PostHandler(IEndpoint sagaRunner, [NotNull] IServiceBus bus)
{
if (sagaRunner == null)
throw new ArgumentNullException("sagaRunner");
if (bus == null) throw new ArgumentNullException("bus");
_sagaRunner = sagaRunner;
_bus = bus;
}
/// <summary>
/// Создает временную конечную точку для получения сообщений.
/// </summary>
/// <param name="endpoint">Конечная точка шины сообщений для который создается подписка.</param>
/// <param name="label">Метка сообщений, на которые ожидается получение ответа.</param>
/// <returns>
/// Конечная точка подписки для получения сообщений.
/// </returns>
public ISubscriptionEndpoint BuildTempReplyEndpoint(IEndpoint endpoint, MessageLabel label)
{
var queue = Queue.Named(string.Format("{0}.replies-{1}-{2}", endpoint.Address, label.IsAny ? "any" : label.Name, NameGenerator.GetRandomName(8)))
.AutoDelete.Exclusive.Instance;
this.rabbitChannel.Declare(queue);
return new SubscriptionEndpoint(queue, new StaticRouteResolver(string.Empty, queue.Name));
}
public ReceivedTransportMessage(string messageType, PeerId peerId, Guid messageIdentity, IEndpoint endpoint, byte[] data, int? sequenceNumber)
{
PeerId = peerId;
MessageIdentity = messageIdentity;
MessageType = messageType;
Data = data;
SequenceNumber = sequenceNumber;
Endpoint = endpoint;
}
public EndpointMessageSink(IEndpoint endpoint)
{
_endpoint = endpoint;
}
public IOutboundRoutingConfiguration Add <TMessage>(IEndpoint endpoint, Type outboundConnectorType) => Add(typeof(TMessage), endpoint, outboundConnectorType);
public TShapedNexus(IEndpoint connectToPoint1 = null, IEndpoint connectToPoint2 = null,
IEndpoint connectToPoint3 = null)
: base(3, connectToPoint1, connectToPoint2, connectToPoint3)
{
}
private static string HandleRequest(IEndpoint <Links, string> endpoint, string requestUri, ILogger logger)
{
var result = endpoint.Invoke(requestUri);
return(Serialize(result, logger));
}
public EndpointMiddleware(IEndpoint <TResult> endpoint, IEnumerable <HttpMethod> allowedMethods = null, bool exactRequestPathMatching = true, ILogger logger = null)
: this(allowedMethods, exactRequestPathMatching, logger)
{
_endpoint = endpoint ?? throw new ArgumentNullException(nameof(endpoint));
}
public void Send(IEndpoint endpoint, object message, Action <ISendContext> contextCallback)
{
var msg = message as TMessage;
endpoint.Send(msg, context => contextCallback(context));
}
public override bool OnWsConnecting(HttpRequest request, HttpResponse response)
{
_matchedEndpoint = _server._endpoints.Find(e => e.Matches(request));
return(_matchedEndpoint != null);
}
/// <summary>
/// Pings the endpoint specified
/// </summary>
/// <param name="endpoint"></param>
/// <param name="ct">Optional cancellation token to cancel pending request</param>
/// <returns>HTTP error if there is a problem with the request, otherwise an
/// empty <see cref="IPortalResponse"/> object if successful otherwise the Error property is populated</returns>
public virtual Task <PortalResponse> Ping(IEndpoint endpoint, CancellationToken ct)
{
return(Get <PortalResponse>(endpoint, ct));
}
public TestMiddleware2(IEndpoint <string, string> endpoint, IManagementOptions mgmtOptions, ILogger logger)
: base(endpoint, mgmtOptions, logger: logger)
{
}
/// <summary>
/// Pings the endpoint specified
/// </summary>
/// <param name="endpoint"></param>
/// <param name="ct">Optional cancellation token to cancel pending request</param>
/// <returns>HTTP error if there is a problem with the request, otherwise an
/// empty <see cref="IPortalResponse"/> object if successful otherwise the Error property is populated</returns>
public virtual Task <PortalResponse> Ping(IEndpoint endpoint, CancellationToken ct = default(CancellationToken))
{
return(Get <PortalResponse, ArcGISServerOperation>(new ArcGISServerOperation(endpoint), ct));
}
public TestConsumer(IBroker broker, IEndpoint endpoint, IEnumerable <IConsumerBehavior> behaviors)
: base(broker, endpoint, behaviors)
{
}
public void SetEndpoint(IEndpoint endpoint)
{
_context.SetEndpoint(endpoint);
}
public GeocodeOperation(IEndpoint endpoint, Action beforeRequest = null, Action <string> afterRequest = null)
: base(endpoint, beforeRequest, afterRequest)
{
}
public virtual Task <PortalResponse> Ping(IEndpoint endpoint)
{
return(Ping(endpoint, CancellationToken.None));
}
public (string?Value1, string?Value2) GetAdditionalValues(
IEndpoint endpoint,
IReadOnlyCollection <MessageHeader>?headers,
IBrokerMessageIdentifier?brokerMessageIdentifier) =>
(null, null);
protected Task <T> Get <T>(IEndpoint endpoint, CancellationToken ct) where T : IPortalResponse
{
return(Get <T>(endpoint.BuildAbsoluteUrl(RootUrl), ct));
}
public void Send(IEndpoint endpoint, object message)
{
var msg = message as TMessage;
endpoint.Send(msg);
}
public PartnerApiRequestBuilder WithEndpoint(IEndpoint value)
{
m_endpoint = value;
return(this);
}
/// <summary>
/// Creates a new element collection endpoint.
/// </summary>
/// <param name="referrer">The endpoint used to navigate to this one.</param>
/// <param name="relativeUri">The URI of this endpoint relative to the <paramref name="referrer"/>'s. Prefix <c>./</c> to append a trailing slash to the <paramref name="referrer"/> URI if missing.</param>
public IndexerEndpoint(IEndpoint referrer, string relativeUri)
: base(referrer, relativeUri)
{
SetupElementHandling();
}
/// <summary>
/// Create a new outgoing call to phones, SIP-enabled endpoints or Twilio Client connections
/// </summary>
///
/// <param name="to"> Phone number, SIP address or client identifier to call </param>
/// <param name="from"> Twilio number from which to originate the call </param>
/// <param name="pathAccountSid"> The account_sid </param>
/// <param name="url"> Url from which to fetch TwiML </param>
/// <param name="applicationSid"> ApplicationSid that configures from where to fetch TwiML </param>
/// <param name="method"> HTTP method to use to fetch TwiML </param>
/// <param name="fallbackUrl"> Fallback URL in case of error </param>
/// <param name="fallbackMethod"> HTTP Method to use with FallbackUrl </param>
/// <param name="statusCallback"> Status Callback URL </param>
/// <param name="statusCallbackEvent"> The status_callback_event </param>
/// <param name="statusCallbackMethod"> HTTP Method to use with StatusCallback </param>
/// <param name="sendDigits"> Digits to send </param>
/// <param name="ifMachine"> Action to take if a machine has answered the call </param>
/// <param name="timeout"> Number of seconds to wait for an answer </param>
/// <param name="record"> Whether or not to record the Call </param>
/// <param name="recordingChannels"> The recording_channels </param>
/// <param name="recordingStatusCallback"> The recording_status_callback </param>
/// <param name="recordingStatusCallbackMethod"> The recording_status_callback_method </param>
/// <param name="sipAuthUsername"> The sip_auth_username </param>
/// <param name="sipAuthPassword"> The sip_auth_password </param>
/// <param name="client"> Client to make requests to Twilio </param>
/// <returns> Task that resolves to A single instance of Call </returns>
public static async System.Threading.Tasks.Task<CallResource> CreateAsync(IEndpoint to, Types.PhoneNumber from, string pathAccountSid = null, Uri url = null, string applicationSid = null, Twilio.Http.HttpMethod method = null, Uri fallbackUrl = null, Twilio.Http.HttpMethod fallbackMethod = null, Uri statusCallback = null, List<string> statusCallbackEvent = null, Twilio.Http.HttpMethod statusCallbackMethod = null, string sendDigits = null, string ifMachine = null, int? timeout = null, bool? record = null, string recordingChannels = null, string recordingStatusCallback = null, Twilio.Http.HttpMethod recordingStatusCallbackMethod = null, string sipAuthUsername = null, string sipAuthPassword = null, ITwilioRestClient client = null)
{
var options = new CreateCallOptions(to, from){PathAccountSid = pathAccountSid, Url = url, ApplicationSid = applicationSid, Method = method, FallbackUrl = fallbackUrl, FallbackMethod = fallbackMethod, StatusCallback = statusCallback, StatusCallbackEvent = statusCallbackEvent, StatusCallbackMethod = statusCallbackMethod, SendDigits = sendDigits, IfMachine = ifMachine, Timeout = timeout, Record = record, RecordingChannels = recordingChannels, RecordingStatusCallback = recordingStatusCallback, RecordingStatusCallbackMethod = recordingStatusCallbackMethod, SipAuthUsername = sipAuthUsername, SipAuthPassword = sipAuthPassword};
return await CreateAsync(options, client);
}
public OutboundRoute(Type messageType, IEndpoint destinationEndpoint, Type outboundConnectorType)
{
MessageType = messageType;
DestinationEndpoint = destinationEndpoint;
OutboundConnectorType = outboundConnectorType;
}
public Api(PoyntSDK sdk, params string[] parents) : base(sdk, () => Constants.POYNT_API_HOST + EndpointConfig.Get <TModel>().Resolve(parents))
{
this.endPointRef = EndpointConfig.Get <TModel>();
}
/// <summary>
/// Sends a DELETE request to the given endpoint.
/// </summary>
internal async static Task <Response> Delete <T>(IEndpoint <T> endpoint)
{
if (endpoint == null)
{
throw new ArgumentNullException("Endpoint", "Endpoint should not be null.");
}
HttpResponseMessage httpResponse = null;
Error error = null;
string rawMessage = null;
try
{
//application/x-www-form-urlencoded
Requester.Client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", endpoint.Arguments[0]);
Requester.Client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("*/*"));
Requester.Client.DefaultRequestHeaders.UserAgent.Add(new ProductInfoHeaderValue("MojangSharp", "0.1"));
httpResponse = await Requester.Client.DeleteAsync(endpoint.Address);
rawMessage = await httpResponse.Content.ReadAsStringAsync();
httpResponse.EnsureSuccessStatusCode();
}
catch (Exception ex)
{
if (httpResponse.StatusCode == HttpStatusCode.Unauthorized ||
httpResponse.StatusCode == HttpStatusCode.Forbidden)
{
JObject err = JObject.Parse(rawMessage);
error = new Error()
{
ErrorMessage = err["errorMessage"].ToObject <string>(),
ErrorTag = err["error"].ToObject <string>(),
Exception = ex
};
}
else
{
error = new Error()
{
ErrorMessage = ex.Message,
ErrorTag = ex.GetBaseException().Message,
Exception = ex
};
}
}
return(new Response()
{
Code = httpResponse.StatusCode,
RawMessage = rawMessage,
IsSuccess = httpResponse.IsSuccessStatusCode && (
httpResponse.StatusCode == HttpStatusCode.Accepted ||
httpResponse.StatusCode == HttpStatusCode.Continue ||
httpResponse.StatusCode == HttpStatusCode.Created ||
httpResponse.StatusCode == HttpStatusCode.Found ||
httpResponse.StatusCode == HttpStatusCode.OK ||
httpResponse.StatusCode == HttpStatusCode.PartialContent) &&
error == null,
Error = error
});
}
public static void Register <T>(IEndpoint endpoint)
{
Endpoints[typeof(T)] = endpoint;
}
protected async Task <T> Post <T>(IEndpoint endpoint, Dictionary <String, String> parameters, CancellationToken ct) where T : IPortalResponse
{
var url = endpoint.BuildAbsoluteUrl(RootUrl).Split('?').FirstOrDefault();
var token = await CheckGenerateToken(ct);
if (ct.IsCancellationRequested)
{
return(default(T));
}
// these should have already been added
if (!parameters.ContainsKey("f"))
{
parameters.Add("f", "json");
}
if (!parameters.ContainsKey("token") && token != null && !String.IsNullOrWhiteSpace(token.Value))
{
parameters.Add("token", token.Value);
_httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue(token.Value);
if (token.AlwaysUseSsl)
{
url = url.Replace("http:", "https:");
}
}
HttpContent content = null;
try
{
content = new FormUrlEncodedContent(parameters);
}
catch (FormatException)
{
var tempContent = new MultipartFormDataContent();
foreach (var keyValuePair in parameters)
{
tempContent.Add(new StringContent(keyValuePair.Value), keyValuePair.Key);
}
content = tempContent;
}
_httpClient.CancelPendingRequests();
Uri uri;
bool validUrl = Uri.TryCreate(url, UriKind.Absolute, out uri);
if (!validUrl)
{
throw new HttpRequestException(String.Format("Not a valid url: {0}", url));
}
System.Diagnostics.Debug.WriteLine(uri);
String resultString = String.Empty;
try
{
HttpResponseMessage response = await _httpClient.PostAsync(uri, content, ct);
response.EnsureSuccessStatusCode();
resultString = await response.Content.ReadAsStringAsync();
}
catch (TaskCanceledException cex)
{
System.Diagnostics.Debug.WriteLine(cex.ToString());
return(default(T));
}
catch (HttpRequestException)
{
throw;
}
System.Diagnostics.Debug.WriteLine(resultString);
var result = Serializer.AsPortalResponse <T>(resultString);
if (result.Error != null)
{
throw new InvalidOperationException(result.Error.ToString());
}
return(result);
}
public IOutboundRoutingConfiguration Add(Type messageType, IEndpoint endpoint, Type outboundConnectorType)
{
_routes.Add(new OutboundRoute(messageType, endpoint, outboundConnectorType));
return(this);
}
/// <summary>
/// Connection details of API.
/// </summary>
/// <value>Details for connecting to an Endpoint.</value>
public BaseClient(IEndpoint endpoint)
{
this.Endpoint = endpoint;
}
/// <summary>
/// Sends a PUT request to the given endpoint.
/// </summary>
internal async static Task <Response> Put <T>(IEndpoint <T> endpoint, Uri file)
{
if (endpoint == null)
{
throw new ArgumentNullException("Endpoint", "Endpoint should not be null.");
}
if (file == null || string.IsNullOrEmpty(file.ToString()))
{
throw new ArgumentNullException("Skin", "No file given.");
}
HttpResponseMessage httpResponse = null;
Error error = null;
string rawMessage = null;
try
{
//application/x-www-form-urlencoded
Requester.Client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", endpoint.Arguments[0]);
Requester.Client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("*/*"));
Requester.Client.DefaultRequestHeaders.UserAgent.Add(new ProductInfoHeaderValue("MojangSharp", "0.1"));
using (var contents = new MultipartFormDataContent())
{
contents.Add(new StringContent(bool.Parse(endpoint.Arguments[1]) == true ? "true" : "false"), "model");
using (WebClient wc = new WebClient()) {
contents.Add(new ByteArrayContent(wc.DownloadData(file)), "file", Path.GetFileName(file.ToString()));
}
httpResponse = await Requester.Client.PutAsync(endpoint.Address, contents);
rawMessage = await httpResponse.Content.ReadAsStringAsync();
httpResponse.EnsureSuccessStatusCode();
}
}
catch (Exception ex)
{
if (httpResponse.StatusCode == HttpStatusCode.Unauthorized ||
httpResponse.StatusCode == HttpStatusCode.Forbidden)
{
JObject err = JObject.Parse(rawMessage);
error = new Error()
{
ErrorMessage = err["errorMessage"].ToObject <string>(),
ErrorTag = err["error"].ToObject <string>(),
Exception = ex
};
}
else
{
error = new Error()
{
ErrorMessage = ex.Message,
ErrorTag = ex.GetBaseException().Message,
Exception = ex
};
}
}
return(new Response()
{
Code = httpResponse.StatusCode,
RawMessage = rawMessage,
IsSuccess = httpResponse.IsSuccessStatusCode && (
httpResponse.StatusCode == HttpStatusCode.Accepted ||
httpResponse.StatusCode == HttpStatusCode.Continue ||
httpResponse.StatusCode == HttpStatusCode.Created ||
httpResponse.StatusCode == HttpStatusCode.Found ||
httpResponse.StatusCode == HttpStatusCode.OK ||
httpResponse.StatusCode == HttpStatusCode.PartialContent) &&
error == null,
Error = error
});
}
public override object ServiceMessage(IMessage message)
{
CommandMessage commandMessage = message as CommandMessage;
if (commandMessage != null)
{
//Sub/unsub handled by base class
return(base.ServiceMessage(commandMessage));
}
else
{
AsyncMessage responseMessage = null;
DataMessage dataMessage = message as DataMessage;
DataDestination dataDestination = this.GetDestination(dataMessage) as DataDestination;
if (dataDestination.SubscriptionManager.GetSubscriber(dataMessage.clientId as string) == null)
{
//Subscribe here as DS doesn't send a separate subscribe command
CommandMessage commandMessageSubscribe = new CommandMessage();
commandMessageSubscribe.destination = dataDestination.Id;
commandMessageSubscribe.operation = CommandMessage.SubscribeOperation;
commandMessageSubscribe.clientId = dataMessage.clientId as string;
string endpointId = dataMessage.GetHeader(MessageBase.EndpointHeader) as string;
commandMessageSubscribe.headers[MessageBase.EndpointHeader] = endpointId;
string flexClientIdHeader = dataMessage.GetHeader(MessageBase.FlexClientIdHeader) as string;
if (flexClientIdHeader != null)
{
commandMessageSubscribe.headers[MessageBase.FlexClientIdHeader] = flexClientIdHeader;
}
IEndpoint endpoint = GetMessageBroker().GetEndpoint(endpointId);
endpoint.ServiceMessage(commandMessageSubscribe); //route through the endpoint again
//base.ServiceMessage(commandMessageSubscribe);
}
switch (dataMessage.operation)
{
case DataMessage.FillOperation:
responseMessage = ExecuteFillOperation(message);
break;
case DataMessage.GetOperation:
responseMessage = ExecuteGetOperation(message);
break;
case DataMessage.BatchedOperation:
case DataMessage.MultiBatchOperation:
case DataMessage.TransactedOperation:
responseMessage = ExecuteMultiBatchOperation(message);
break;
case DataMessage.PageItemsOperation:
responseMessage = ExecutePageItemsOperation(message);
break;
case DataMessage.PageOperation:
responseMessage = ExecutePageOperation(message);
break;
case DataMessage.ReleaseCollectionOperation:
responseMessage = ExecuteReleaseCollectionOperation(message);
break;
case DataMessage.GetSequenceIdOperation:
responseMessage = ExecuteGetSequenceIdOperation(message);
break;
case DataMessage.ReleaseItemOperation:
responseMessage = ExecuteReleaseItemOperation(message);
break;
default:
if (log.IsErrorEnabled)
{
log.Error(__Res.GetString(__Res.DataService_Unknown, dataMessage.operation));
}
responseMessage = new AcknowledgeMessage();
break;
}
responseMessage.clientId = message.clientId;
responseMessage.correlationId = message.messageId;
//Dump();
return(responseMessage);
}
}
public Form1(IEndpoint endPoint)
{
InitializeComponent();
_endPoint = endPoint;
}
