public static bool UpdateTask(TaskDTO task)
{
_responder = GameObject.FindGameObjectWithTag("MainCamera").GetComponent <Responder>();
var data = new WWWForm();
data.AddField("id", task.Id);
data.AddField("worker", task.WorkerId);
data.AddField("description", task.Description);
data.AddField("deadline", task.Deadline);
_responder.Send("tasks/update_task", data);
LogsController.AddLog(PlayerPrefs.GetString("SessionUserId"), "UPDATE TASK",
string.Format("Id: \"{0}\"; WorkerId: \"{1}\"; Description: \"{2}\"; Deadline: \"{3}\"",
task.Id, task.WorkerId, task.Description, task.Deadline));
return(Convert.ToBoolean(_responder.Responce));
}
private void SubcribeToRequest()
{
responder = new Responder(logger);
try
{
CreateSubscribeToQueries();
CreateSubscribeToQueriesWithCancellation();
CreateSubscribeToCommands();
}
catch (Exception ex)
{
logger.LogWarning($"Responder SubscribeToRequests EXCEPTION:{ex.Message}");
}
Console.ReadKey();
}
protected override void Awake()
{
base.Awake();
enemy = Utils.GetRequiredComponent <Enemy>(this);
chaser = Utils.GetRequiredComponent <Chaser>(this);
responder = Utils.GetRequiredComponent <Responder>(this);
waiter = Utils.GetRequiredComponent <Waiter>(this);
patroller = Utils.GetRequiredComponent <Patroller>(this);
animator = Utils.GetRequiredComponentInChildren <Animator>(this);
originPosition = transform.position;
originRotation = transform.rotation;
}
/// <summary>
/// See base docs.
/// </summary>
/// <param name="server"></param>
/// <param name="args"></param>
/// <returns></returns>
protected override bool DoHandleRequest(IWebServer server, RequestReceivedEventArgs args)
{
if ("/DirectoryEntry.json".Equals(args.PathAndFile, StringComparison.OrdinalIgnoreCase))
{
var key = (args.QueryString["key"] ?? "");
if (!String.IsNullOrEmpty(_Key) && _Key.Equals(key, StringComparison.OrdinalIgnoreCase))
{
var directoryEntry = BuildDirectoryEntry();
Responder.SendJson(args.Request, args.Response, directoryEntry, null, null);
args.Handled = true;
}
}
return(args.Handled);
}
protected override bool DoHandleRequest(IWebServer server, RequestReceivedEventArgs args)
{
var result = false;
if (args.PathAndFile.Equals("/PolarPlot.json", StringComparison.OrdinalIgnoreCase))
{
result = true;
var allowRequest = _InternetClientCanShowPolarPlot || !args.IsInternetRequest;
var feedId = allowRequest ? QueryInt(args, "feedId", -1) : -1;
var json = new PolarPlotsJson()
{
FeedId = feedId,
};
if (allowRequest)
{
var feed = _FeedManager.GetByUniqueId(feedId, ignoreInvisibleFeeds: true);
var polarPlotter = feed == null || feed.AircraftList == null ? null : feed.AircraftList.PolarPlotter;
if (polarPlotter != null)
{
foreach (var slice in polarPlotter.TakeSnapshot())
{
var jsonSlice = new PolarPlotsSliceJson()
{
StartAltitude = slice.AltitudeLower,
FinishAltitude = slice.AltitudeHigher,
};
json.Slices.Add(jsonSlice);
foreach (var kvp in slice.PolarPlots.OrderBy(r => r.Key))
{
var plot = kvp.Value;
jsonSlice.Plots.Add(new PolarPlotJson()
{
Latitude = (float)plot.Latitude,
Longitude = (float)plot.Longitude,
});
}
}
}
}
Responder.SendJson(args.Request, args.Response, json, null, null);
}
return(result);
}
// =====================================================================
/// <inheritdoc />
public void setAudioCaptureDevice(Responder <object> responder,
string deviceId)
{
if (!isPlatformInitialized <object>(responder))
{
return;
}
ADLString devId = StringHelper.toNative(deviceId);
NativeAPI.adl_set_audio_capture_device(
_voidRCallback,
_platformHandle,
saveResponder(responder),
ref devId);
}
/**
* CloudeoService - Connectivity
* =====================================================================
*/
/// <inheritdoc />
public void connect(Responder <object> responder,
ConnectionDescription connDescription)
{
if (!isPlatformInitialized <object>(responder))
{
return;
}
var cdn = connDescription.toNative();
NativeAPI.adl_connect(
_voidRCallback,
_platformHandle,
saveResponder(responder),
ref cdn);
}
// =====================================================================
/// <inheritdoc />
public void unpublish(Responder <object> responder, string scopeId,
MediaType mediaType)
{
if (!isPlatformInitialized <object>(responder))
{
return;
}
ADLString scpId = StringHelper.toNative(scopeId);
ADLString mediaTp =
StringHelper.toNative(mediaType.StringValue);
NativeAPI.adl_unpublish(_voidRCallback,
_platformHandle, saveResponder(responder),
ref scpId, ref mediaTp);
}
// =====================================================================
/// <inheritdoc />
public void sendMessage(Responder <object> responder, string scopeId,
string message, long targetUserId)
{
if (!isPlatformInitialized <object>(responder))
{
return;
}
ADLString scpId = StringHelper.toNative(scopeId);
UIntPtr msgSz =
new UIntPtr((message != null) ? (uint)message.Length : 0u);
NativeAPI.adl_send_message(_voidRCallback,
_platformHandle, saveResponder(responder),
ref scpId, message, msgSz, ref targetUserId);
}
void Start()
{
requester = gameObject.AddComponent <Requester>();
requester.deivceName = myname;
requester.ignoreDeivceName = myname;
requester.desktopMode = true;
responder = gameObject.AddComponent <Responder>();
responder.deivceName = myname;
responder.ignoreDeivceName = myname;
responder.desktopMode = true;
responder.OnRequested = () => {
//見つけた相手のアドレスとポートを自動設定
window.ChangeExternalMotionSenderAddress(responder.requestIpAddress, responder.requestServicePort);
};
}
/// <summary>
/// 初始化和连接服务器
/// </summary>
/// <param name="host">服务器地址</param>
/// <param name="port">服务器端口号</param>
public void InitAndConnect(string host, int port, Responder responsor, NetworkManager networkManager)
{
Log(Name, string.Format("初始化客户端，服务器地址：{0}，服务器端口号：{1},时间:{2}", host, port, DataTime2String(DateTime.Now)));
_responsor = responsor;
_networkManager = networkManager;
Host = host;
Port = port;
HasConnectedToServer = false;
ConnectStartTime = DateTime.Now;
HasConnectedToServer = false;
Connect();
}
public override void Execute()
{
using (FalconOrchestratorDB db = new FalconOrchestratorDB())
{
string dayOfWeek = model.Data.FormattedProcessStartTime.Value.DayOfWeek.ToString();
Responder responder = Persistence.GetAssignedResponder(dayOfWeek);
if (responder != null)
{
model.Data.ResponderId = responder.ResponderId;
log.Debug("Assign responder rule enabled, schedule has " + responder.FirstName + " " + responder.LastName + " assigned for " + dayOfWeek);
}
else
{
log.Warn("Assign responder rule enabled, however no responder has been scheduled for " + dayOfWeek);
}
}
}
public async Task <ObjectResult> DeleteEmployee(int employeeId)
{
try
{
Result result = await employeeService.DeleteEmployeeAsync(employeeId);
if (result.status == 200)
{
return(Ok(Responder.Success(result.data)));
}
return(StatusCode(result.status, Responder.Fail(result.data)));
}
catch (Exception error)
{
return(BadRequest(Responder.Fail(error.Message)));
}
}
void webEvent_dispatcher(string path, WebServer.HttpMethod method, Responder responder)
{
if (method.Equals(WebServer.HttpMethod.PUT))
{
string firstURLParam = path.Substring(0, path.IndexOf("/"));
#if DEBUG
Debug.Print("Called PUT " + path);
Debug.Print("URL starts with " + firstURLParam);
#endif
switch (firstURLParam)
{
case "lights":
#if DEBUG
Debug.Print("Called PUT the lights " + path.Substring(path.LastIndexOf("/")));
#endif
putLightsManager(path.Substring(path.IndexOf("/") + 1));
break;
case "automatic_light":
putAutomaticLightsManager(path.Substring(path.IndexOf("/") + 1));
break;
case "automatic_heather":
putAutomaticHeatherManager(path.Substring(path.IndexOf("/") + 1));
break;
case "heather":
putHeatherManager(path.Substring(path.IndexOf("/") + 1));
break;
default:
lock (board.lokcker)
{
responder.Respond(Encoding.UTF8.GetBytes("\"KO\""), "text/json");
}
return;
}
}
lock (board)
{
responder.Respond(Encoding.UTF8.GetBytes("\"OK\""), "text/json");
}
}
public static void Base64Data()
{
var responder = new Responder();
var response = responder.Respond(GetQueryRequest("base64DataCount_0"));
var expected_response = GetQueryResponse("base64DataCount_0");
Assert.AreEqual(expected_response, response, "response base64DataCount_0");
var base64_fragment = "iVBORw0KGgoAAAANSUhEUg";
response = responder.Respond(GetMutationRequest("insertBase64Data"));
Assert.True(response.Contains("graphql.png"));
Assert.True(response.Contains(base64_fragment));
response = responder.Respond(GetQueryRequest("base64Data"));
Assert.True(response.Contains("graphql.png"));
Assert.True(response.Contains(base64_fragment));
}
/// <summary>
/// Handles the request for the server configuration JSON.
/// </summary>
/// <param name="server"></param>
/// <param name="args"></param>
/// <returns></returns>
protected override bool DoHandleRequest(IWebServer server, RequestReceivedEventArgs args)
{
if ("/ServerConfig.json".Equals(args.PathAndFile, StringComparison.OrdinalIgnoreCase))
{
ServerConfigJson json;
lock (_ServerConfigJson) json = (ServerConfigJson)_ServerConfigJson.Clone();
json.IsLocalAddress = !args.IsInternetRequest;
if (json.IsLocalAddress && !_UseGoogleMapsAPIKeyWithLocalRequests)
{
json.GoogleMapsApiKey = null;
}
Responder.SendJson(args.Request, args.Response, json, null, null);
args.Handled = true;
}
return(args.Handled);
}
public GlooServer(BamConf conf, ILogger logger, bool verbose = false)
: base(new GlooResponder(conf, logger, verbose), logger)
{
Responder.Initialize();
CreatedOrChangedHandler = (o, fsea) =>
{
ReloadServices(fsea);
};
RenamedHandler = (o, rea) =>
{
DirectoryInfo dir = GetDirectory(rea.FullPath);
if (dir != null)
{
TryReloadServices(dir);
}
};
ServiceTypes = new HashSet <Type>();
}
/**
* NativeAPI callback handlers
* =====================================================================
*/
/// <summary>
///
/// </summary>
/// <param name="opaque"></param>
/// <param name="error"></param>
private void voidRCallback(IntPtr opaque, ref ADLError error)
{
Responder <object> responder = (Responder <object>)getResponder(
(uint)opaque);
try
{
if (error.err_code == 0)
{
responder.resultHandler(null);
}
else
{
responder.errHandler(error.err_code, error.err_message.body);
}
}
catch (Exception) { }
}
void seePicture_WebEventReceived(string path, WebServer.HttpMethod method, Responder responder)
{
if (pic != null)
{
Bitmap b = new Bitmap(320, 240);
b.DrawLine(Colors.Red, 20, 0, 0, 319, 239);
byte[] buff = new byte[320 * 240 * 3 + 54];
GHIElectronics.NETMF.System.Util.BitmapToBMPFile(b.GetBitmap(), 320, 240, buff);
GT.Picture picture = new GT.Picture(buff, GT.Picture.PictureEncoding.BMP);
responder.Respond(picture);
}
else
{
responder.Respond("Take picture first");
}
}
/// <summary>
/// Start discovery with custom ports
/// </summary>
/// <param name="port">Port to use</param>
/// <param name="localHostOnly">Respond only on local host</param>
/// <param name="ipv6">Support IPv6 discovery (if available on adapters)</param>
internal static void Start(int port, bool localHostOnly, bool ipv6)
{
if (AlpacaSettings.AllowDiscovery)
{
Console.WriteLine($"Starting Discovery on port: {port}");
if (!Dns.GetHostAddresses(Dns.GetHostName()).Any(o => o.AddressFamily == System.Net.Sockets.AddressFamily.InterNetworkV6))
{
ipv6 = false;
}
DiscoveryResponder = new Responder(port, true, ipv6)
{
AllowRemoteAccess = !localHostOnly,
LocalRespondOnlyToLocalHost = AlpacaSettings.LocalRespondOnlyToLocalHost
};
}
}
public async Task <object> Logout()
{
try
{
StringValues token;
Request.Headers.TryGetValue("token", out token);
string _token = token.FirstOrDefault();
if (_token == null || _token == "")
{
return(Ok(Responder.Success("Already logout")));
}
return(Ok(Responder.Success(new { access_token = "null" })));
}
catch (Exception error)
{
return(BadRequest(Responder.Fail(error.Message)));
}
}
/// <summary>
/// See base class.
/// </summary>
/// <param name="server"></param>
/// <param name="args"></param>
/// <returns></returns>
protected override bool DoHandleRequest(IWebServer server, RequestReceivedEventArgs args)
{
bool result = false;
var key = args.PathAndFile.ToUpper();
if (key == "/")
{
switch (args.Request.Url.Scheme)
{
case "http":
case "https":
int defaultPort = args.Request.Url.Scheme == "http" ? 80 : 443;
string redirectUrl = String.Format("{0}{1}{2}",
args.Request.Url.AbsoluteUri,
args.Request.Url.AbsoluteUri.EndsWith("/") ? "" : "/",
args.IsAndroid || args.IsIPad || args.IsIPhone || args.IsIPod ? "iPhoneMap.htm" : "GoogleMap.htm");
result = true;
args.Response.Redirect(redirectUrl);
break;
default:
break;
}
}
else
{
Content content;
result = _PathAndFileToContentMap.TryGetValue(key, out content);
if (result)
{
string text = content.Text;
if (key == "/SERVERCONFIG.JS")
{
text = text.Replace("__IS_LOCAL_ADDRESS", args.IsInternetRequest ? "false" : "true");
}
Responder.SendText(args.Response, text, Encoding.UTF8, content.MimeType);
args.Classification = ContentClassification.Html;
}
}
return(result);
}
// secure reception of wifi credentials over wifi network - secured by receiving secret
void CredentialsWebEventReceived(string path, WebServer.HttpMethod method, Responder responder)
{
if (responder.UrlParameters == null || !responder.UrlParameters.Contains("ssid") || !responder.UrlParameters.Contains("setupauthcode"))
{
responder.Respond("ERROR::Syntax: " + path + "?ssid=SSID&setupauthcode=SETUPAUTHCODE[&key=WIFIKEY]");
return;
}
if (((string)responder.UrlParameters["setupauthcode"]) != SetupAuthCode)
{
responder.Respond("ERROR::Incorrect setupauthcode");
return;
}
var ssid = responder.UrlParameters["ssid"] as string;
if (ssid == null || ssid == "")
{
responder.Respond("ERROR::Invalid SSID");
return;
}
var key = "";
if (responder.UrlParameters.Contains("key"))
{
key = responder.UrlParameters["key"] as string;
}
Debug.Print("Received (via web event) credentials for network " + ssid);
bool newcreds = ReceivedCredentials(ssid, key);
if (newcreds)
{
responder.Respond("OK::Got new credentials");
SaveData();
Thread.Sleep(10);
WebServer.StopLocalServer();
currentAP = null;
SetLed();
SetScreen();
wifi.Interface.Disconnect();
}
else
{
responder.Respond("OK::Already had those");
}
}
// =====================================================================
/// <inheritdoc />
public void addServiceListener(Responder <object> responder,
AddLiveServiceListener listener)
{
if (!isPlatformInitialized <object>(responder))
{
return;
}
NativeServiceListenerAdapter listenerAdapter =
new NativeServiceListenerAdapter(listener);
ADLServiceListener listenerNative = listenerAdapter.toNative();
NativeAPI.adl_add_service_listener(
_voidRCallback,
_platformHandle,
saveResponder(responder),
ref listenerNative);
_listeners.Add(listenerAdapter);
}
static void Main()
{
Console.WriteLine("Server example started");
const int recivePort = 6000;
var responder = new Responder();
responder.StartResponding(recivePort);
responder.StopResponding();
//Thread.Sleep(100);
responder.StartResponding(recivePort);
Console.WriteLine("Start waiting for request at port {0}...", recivePort);
Console.ReadKey();
}
private async Task <Activity> getFullBalance(Accounts userAccount, Responder responder, Activity activity)
{
string comment;
string imageUrl;
if (userAccount.Cheque + userAccount.Savings > 10000)
{
comment = responder.positive();
imageUrl = responder.positiveImageUrl();
}
else if (userAccount.Cheque + userAccount.Savings > 100)
{
comment = responder.neutral();
imageUrl = responder.neutralImageUrl();
}
else
{
comment = responder.negative();
imageUrl = responder.negativeImageUrl();
}
Activity replyToConversation = activity.CreateReply(comment);
replyToConversation.Recipient = activity.From;
replyToConversation.Type = "message";
replyToConversation.Attachments = new List <Attachment>();
List <CardImage> cardImages = new List <CardImage>();
cardImages.Add(new CardImage(url: imageUrl));
ThumbnailCard balanceCard = new ThumbnailCard()
{
Title = "Your Balance",
Subtitle = $"Cheque Account: {userAccount.Cheque}\n Savings Account: {userAccount.Savings}",
Images = cardImages
};
Attachment balanceAttachment = balanceCard.ToAttachment();
replyToConversation.Attachments.Add(balanceAttachment);
return(replyToConversation);
}
public ObjectResult CreateNewUser([FromBody] SQLiteUser user)
{
try
{
Result result = userSQLiteService.InsertUser(user, APIConnecter.SQLite);
if (result.status == Status.Created)
{
return(Ok(Responder.Success(result.data)));
}
else
{
return(StatusCode(result.status, Responder.Fail(result.data)));
}
}
catch (Exception error)
{
return(BadRequest(Responder.Fail(error.Message)));
}
}
public RealtimeStream(ChannelInstance channel, string keyword)
{
this.Channel = channel;
this.Keyword = keyword;
this.mailbox = VirtualMailBox.Current;
this.markreadtimer = new DispatcherTimer(DispatcherPriority.Normal, Dispatcher)
{
Interval = TimeSpan.FromMilliseconds(400), IsEnabled = false
};
this.markreadtimer.Tick += MarkReadTimerTick;
InitializeComponent();
StreamStatusUpdatesSource = new CollectionViewSource {
Source = State.StatusUpdates
};
MentionsStatusUpdatesSource = new CollectionViewSource {
Source = State.StatusUpdates
};
StreamStatusUpdatesSource.SortDescriptions.Add(new SortDescription("ParentSortDate", ListSortDirection.Descending));
StreamStatusUpdatesSource.SortDescriptions.Add(new SortDescription("SortDate", ListSortDirection.Ascending));
StreamStatusUpdatesSource.View.Filter = StreamStatusUpdatesSourceFilter;
MentionsStatusUpdatesSource.SortDescriptions.Add(new SortDescription("ParentSortDate", ListSortDirection.Descending));
MentionsStatusUpdatesSource.SortDescriptions.Add(new SortDescription("SortDate", ListSortDirection.Ascending));
MentionsStatusUpdatesSource.View.Filter = MentionsStatusUpdatesSourceFilter;
DataContext = this;
mailbox.InboxLoadComplete += delegate
{
StreamStatusUpdatesSource.View.Refresh();
MentionsStatusUpdatesSource.View.Refresh();
};
EventBroker.Subscribe(AppEvents.SyncStatusUpdatesFinished, () => ThreadPool.QueueUserWorkItem(UpdateCountAsync));
Responder.SetIsFirstResponder(SupportsMentions ? Stream2ListView : Stream1ListView, true);
ThreadPool.QueueUserWorkItem(UpdateCountAsync);
}
public ExampleDSLink(Configuration config) : base(config)
{
Responder.AddNodeClass("testAction", delegate(Node node)
{
node.AddParameter(new Parameter("string", "string"));
node.AddParameter(new Parameter("int", "int"));
node.AddParameter(new Parameter("number", "number"));
node.AddColumn(new Column("success", "bool"));
var handler = new ActionHandler(Permission.Write, async(request) =>
{
await request.UpdateTable(new Table
{
new Row
{
true
}
});
await request.Close();
});
node.SetAction(handler);
});
Responder.AddNodeClass("rng", delegate(Node node)
{
node.Writable = Permission.Read;
node.ValueType = ValueType.Number;
node.Value.Set(0.1);
lock (_values)
{
_values.Add(node.Value);
}
});
Task.Run(async() =>
{
await Task.Delay(5000);
UpdateRandomNumbers();
});
}
public static void InvokeAsync <T>(string className, string methodName, object[] args, bool enableUnderFlowInspection, AsyncCallback <T> callback)
{
var responder = new Responder <T>(response =>
{
if (callback != null)
{
callback.ResponseHandler.Invoke(response);
}
}, fault =>
{
var backendlessFault = new BackendlessFault(fault);
if (callback != null)
{
callback.ErrorHandler.Invoke(backendlessFault);
}
else
{
throw new BackendlessException(backendlessFault);
}
});
try
{
ResponseThreadConfigurator responseConfig = null;
if (enableUnderFlowInspection)
{
responseConfig = new ResponseThreadConfigurator(SetupUnderFlowListener);
}
client.Invoke <T>(className, methodName, args, null, HeadersManager.GetInstance().Headers, responder, responseConfig);
}
catch (System.Exception ex)
{
var backendlessFault = new BackendlessFault(ex.Message);
if (callback != null)
{
callback.ErrorHandler.Invoke(backendlessFault);
}
throw new BackendlessException(backendlessFault);
}
}
/// <summary>
/// Tests the broker.
/// </summary>
private static void TestBroker()
{
var responder = new Responder();
Broker.Current.Publish(new TextMessage("Hello."));
var subscriber = new SubscriberAndUnsubscriber();
subscriber.Subscribe();
Broker.Current.Publish(new TextMessage("Sent after subscribe."));
Broker.Current.Publish(new TextMessage("Sent to type."), typeof (Responder));
Broker.Current.Publish(new TextMessage("Sent to object."), subscriber);
subscriber.Ubsubscribe();
Broker.Current.Publish(new TextMessage("Sent after unsubscribe."));
// Shouldn't be received.
Broker.Current.Publish(new TextMessage("Sent to object after unsubscribe."), subscriber);
}
public void One_Responder_1_Requester()
{
var echoWorker = new ResponderWorker();
var workerFactory = new ResponderWorkerFactory(request => echoWorker);
using (var responder = new Responder(workerFactory))
using (var requester = new Requester())
{
var endpoint = GetEndpoint();
responder.Bind(endpoint);
requester.Connect(endpoint);
Thread.Sleep(100);
var sw = Stopwatch.StartNew();
var messageSent = new TestMessage();
for (var i = 0; i < NumberOfRequests; i++)
{
requester.Request(messageSent);
}
sw.Stop();
Assert.Inconclusive("{0} elapsed sending/receiving {1} messages ({2:N0} per second)", sw.Elapsed, NumberOfRequests, NumberOfRequests / sw.Elapsed.TotalSeconds);
}
}
/// <summary>
/// Logs out from session and closes the network connection
/// </summary>
/// <param name="reason"></param>
public void Disconnect(string reason)
{
lock (sync_)
{
if (null != responder_)
{
this.Log.OnEvent("Session " + this.SessionID + " disconnecting: " + reason);
responder_.Disconnect();
responder_ = null;
}
else
{
this.Log.OnEvent("Session " + this.SessionID + " already disconnected: " + reason);
}
if (state_.ReceivedLogon || state_.SentLogon)
{
state_.ReceivedLogon = false;
state_.SentLogon = false;
this.Application.OnLogout(this.SessionID);
}
state_.SentLogout = false;
state_.ReceivedReset = false;
state_.SentReset = false;
state_.ClearQueue();
state_.LogoutReason = "";
if (this.ResetOnDisconnect)
state_.Reset();
state_.SetResendRange(0, 0);
}
}
public void GetSummonerByNameAsync(string name, Responder<PublicSummoner> responder)
{
GetSummonerByNameInternal(responder, new object[] { name });
}
public void RetrievePlayerStatsByAccountIDAsync(int accountID, string season, Responder<PlayerLifeTimeStats> responder)
{
RetrievePlayerStatsByAccountIDInternal(responder, new object[] { accountID, season });
}
private void One_Responder_N_Requesters(int n)
{
var echoWorker = new ResponderWorker();
var workerFactory = new ResponderWorkerFactory(request => echoWorker);
using (var responder = new Responder(workerFactory))
{
var endpoint = GetEndpoint();
responder.Bind(endpoint);
var requesters = Enumerable.Range(0, n).Select(x => new Requester()).ToList();
foreach (var requester in requesters)
{
requester.Connect(endpoint);
}
Thread.Sleep(100);
var threadsStartedSignal = new CounterSignal(n, 0);
var startSignal = new ManualResetEventSlim();
var tasks = new List<Task>();
foreach (var requester in requesters)
{
var req = requester;
var task = Task.Factory.StartNew(() =>
{
threadsStartedSignal.Increment();
startSignal.Wait();
var message = new TestMessage();
for (var i = 0; i < NumberOfRequests / n; i++)
{
req.Request(message);
}
}, TaskCreationOptions.LongRunning);
tasks.Add(task);
}
Assert.IsTrue(threadsStartedSignal.Wait(TimeSpan.FromSeconds(1)));
var sw = Stopwatch.StartNew();
startSignal.Set();
Assert.IsTrue(Task.WhenAll(tasks).Wait(TimeSpan.FromMinutes(1)));
sw.Stop();
foreach (var requester in requesters)
{
requester.Disconnect();
}
Assert.Inconclusive("{0} elapsed sending/receiving {1} messages ({2:N0} per second)", sw.Elapsed, NumberOfRequests, NumberOfRequests / sw.Elapsed.TotalSeconds);
}
}
public void RetrievePlayerStatsByAccountIDInternal(Responder<PlayerLifeTimeStats> responder, object[] arguments)
{
RPCNetConnection.Call(EndpointString, PlayerStatsService, null, "retrievePlayerStatsByAccountId", responder, arguments);
}
public void SetResponder(Responder responder)
{
if (!IsSessionTime)
Reset("Out of SessionTime at setting responder");
lock (sync_)
{
responder_ = responder;
}
}
public PendingCall(Responder<RenderingWidget> rendererResponder
)
{
this.manual = false;
this.rendererResponder = rendererResponder;
}
public void GetAggregatedStatsInternal(Responder<AggregatedStats> responder, object[] arguments)
{
RPCNetConnection.Call(EndpointString, PlayerStatsService, null, "getAggregatedStats", responder, arguments);
}
public void GetAllPublicSummonerDataByAccountAsync(int accountID, Responder<AllPublicSummonerDataDTO> responder)
{
GetAllPublicSummonerDataByAccountInternal(responder, new object[] { accountID });
}
public void manualRenderSink(Responder<ManualRenderer> responder, RenderOptions options)
{
PendingCall call = new PendingCall(responder);
renderSinkInternal(call, options);
}
public void GetRecentGamesAsync(int accountID, Responder<RecentGames> responder)
{
GetRecentGamesInternal(responder, new object[] { accountID });
}
//This call is not exposed to the outside
void GetLoginDataPacketForUserInternal(Responder<LoginDataPacket> responder)
{
RPCNetConnection.Call(EndpointString, ClientFacadeService, null, "getLoginDataPacketForUser", responder, new object[] {});
}
public void GetAllSummonerDataByAccountInternal(Responder<AllSummonerData> responder, object[] arguments)
{
RPCNetConnection.Call(EndpointString, SummonerService, null, "getAllSummonerDataByAccount", responder, arguments);
}
public PendingCall(Responder<ManualRenderer> rendererResponder)
{
this.manual = true;
this.manualRendererResponder = rendererResponder;
}
void GetRecentGamesInternal(Responder<RecentGames> responder, object[] arguments)
{
RPCNetConnection.Call(EndpointString, PlayerStatsService, null, "getRecentGames", responder, arguments);
}
// =====================================================================
/// <summary>
///
/// </summary>
/// <param name="responder"></param>
/// <param name="options"></param>
public void renderSink(Responder<RenderingWidget> responder,
RenderOptions options)
{
PendingCall call = new PendingCall(responder);
renderSinkInternal(call, options);
}
void GetSummonerByNameInternal(Responder<PublicSummoner> responder, object[] arguments)
{
RPCNetConnection.Call(EndpointString, SummonerService, null, "getSummonerByName", responder, arguments);
}
public void SetResponder(Responder responder)
{
if (!IsSessionTime)
Reset();
lock (sync_)
{
responder_ = responder;
}
}
public void GetAggregatedStatsAsync(int accountID, string gameMode, string season, Responder<AggregatedStats> responder)
{
GetAggregatedStatsInternal(responder, new object[] { accountID, gameMode, season });
}
