public void HandleData(MemBlock payload, ISender return_path, object state) {
if(_sub != null) {
MemBlock rest = null;
PType.Parse(payload, out rest);
_sub.Handle(rest, return_path);
}
}
void ChangePassword(ISender sender, string password)
{
if (!Storage.IsAvailable)
throw new CommandError("No permissions plugin or data plugin is attached");
var player = sender as Player;
if (player == null)
{
sender.SendMessage("This is a player command", G: 0, B: 0);
return;
}
else if (!player.IsAuthenticated())
{
sender.SendMessage("You are not authenticated.", G: 0, B: 0);
return;
}
else if (password == null || password.Trim().Length < MinPasswordLength)
{
sender.SendMessage("Please specify a password longer than 5 characters.", G: 0, B: 0);
return;
}
var auth = player.GetAuthenticatedAs();
if (Authentication.UpdatePlayer(auth, password))
{
sender.SendMessage("Your password is now updated.", R: 0, B: 0);
}
else
{
sender.SendMessage("Failed to update your password.", G: 0, B: 0);
}
}
public void HandleRpc(ISender caller, string method, IList arguments, object request_state)
{
object result = null;
MemBlock key;
MemBlock value;
int ttl;
try {
switch(method) {
case "Register":
key = MemBlock.Reference((byte[]) arguments[0]);
value = MemBlock.Reference((byte[]) arguments[1]);
ttl = (int) arguments[2];
result = Register(key, value, ttl);
break;
case "Unregister":
key = MemBlock.Reference((byte[]) arguments[0]);
value = MemBlock.Reference((byte[]) arguments[1]);
result = Unregister(key, value);
break;
case "ListEntries":
result = ListEntries();
break;
default:
throw new Exception("Invalid method");
}
}
catch (Exception e) {
result = new AdrException(-32602, e);
}
_rpc.SendResult(request_state, result);
}
public static void SetPoint(Server server, ISender sender, ArgumentList args)
{
string param;
Player player = server.GetPlayerByName(sender.Name);
if (args.TryGetString(0, out param))
{
switch (param.ToUpper())
{
case "LOBBY":
player.PluginData["lobby"] = true;
player.sendMessage("Hit a block where you want the lobby to be", Login.plugin.chatColor);
break;
case "VALIDATED":
player.PluginData["validated"] = true;
player.sendMessage("Hit a block where you want the validated point to be", Login.plugin.chatColor);
break;
default:
player.sendMessage("You must specify either lobby or validated", Login.plugin.chatColor);
break;
}
}
else
player.sendMessage("You must specify either lobby or validated", Login.plugin.chatColor);
}
public static void TestPoint(Server server, ISender sender, ArgumentList args)
{
string param;
Player player = server.GetPlayerByName(sender.Name);
if (args.TryGetString(0, out param))
{
switch (param.ToUpper())
{
case "LOBBY":
player.sendMessage("Teleporting to the lobby", Login.plugin.chatColor);
Login.plugin.TeleportPlayerToPoint(player, Login.LOBBY);
break;
case "VALIDATED":
player.sendMessage("Teleporting to the validated point", Login.plugin.chatColor);
Login.plugin.TeleportPlayerToPoint(player, Login.VALIDATED);
break;
default:
player.sendMessage("You must specify either lobby or validated", Login.plugin.chatColor);
break;
}
}
else
player.sendMessage("You must specify either lobby or validated", Login.plugin.chatColor);
}
/// <summary>
/// Adds a player or ip (Exception) to the ban list.
/// </summary>
/// <param name="sender">Sending player</param>
/// <param name="args">Arguments sent with command</param>
public static void Ban(ISender sender, ArgumentList args)
{
Player banee;
string playerName = null;
if (args.TryGetOnlinePlayer(0, out banee))
{
playerName = banee.Name;
banee.Kick("You have been banned from this Server.");
Server.BanList.addException(NetPlay.slots[banee.whoAmi].
remoteAddress.Split(':')[0]);
}
else if(!args.TryGetString(0, out playerName))
{
throw new CommandError("A player or IP was expected.");
}
Server.BanList.addException(playerName);
Server.notifyOps(playerName + " has been banned {" + sender.Name + "}", true);
if (!Server.BanList.Save())
{
Server.notifyOps("BanList Failed to Save due to " + sender.Name + "'s command", true);
}
}
/// <summary>
/// De-OPs a given Player.
/// </summary>
/// <param name="sender">Sending player</param>
/// <param name="args">Arguments sent with command</param>
public static void DeopPlayer(ISender sender, ArgumentList args)
{
var playerName = args.GetString(0);
Player player;
if (args.TryGetOnlinePlayer(0, out player))
{
playerName = player.Name;
if (Player.isInOpList(playerName))
{
player.sendMessage("You have been De-Opped!.", ChatColor.Green);
}
player.Op = false;
if (player.HasClientMod)
{
NetMessage.SendData(Packet.CLIENT_MOD, player.whoAmi);
}
}
if (Player.isInOpList(playerName))
{
Server.notifyOps("De-Opping " + playerName + " {" + sender.Name + "}", true);
Server.OpList.removeException(playerName + ":" + Player.GetPlayerPassword(playerName));
}
if (!Server.OpList.Save())
{
Server.notifyOps("OpList Failed to Save due. {" + sender.Name + "}", true);
return;
}
}
public void PrivateMessageReply(ISender sender, string message)
{
var playerFrom = sender as Player;
if (playerFrom == null)
{
sender.SendMessage("This is a player command.", G: 0, B: 0);
return;
}
if (String.IsNullOrEmpty(message))
{
sender.SendMessage("Invalid message", G: 0, B: 0);
return;
}
var lastPlayerName = playerFrom.GetPluginData("LastPM", String.Empty);
if(String.IsNullOrEmpty(lastPlayerName))
{
sender.SendMessage("You are required to have started a conversation.", G: 0, B: 0);
return;
}
var playerTo = Tools.GetPlayerByName(lastPlayerName);
if(playerTo == null || !playerTo.active)
{
sender.SendMessage($"Last PM'd user ({lastPlayerName}) is no longer online.", G: 0, B: 0);
return;
}
playerTo.Message(255, Color.Orange, $"[PM] {playerFrom.SenderName}: {message}");
}
/// <summary>Create a DtlsFilter.</summary>
/// <param name="key">A CryptoKey initialized by the OpenSSL.NET library.</param>
/// <param name="cert">The path to the certificate to use.</param>
/// <param name="ca_cert">The path to the ca certificate to use.</param>
/// <param name="client">Use client initialization parameters.</param>
public DtlsAssociation(ISender sender, CertificateHandler ch, PType ptype,
Ssl ssl, bool client) : base(sender, ch)
{
_ip = new IdentifierPair();
PType = ptype;
_ssl = ssl;
_client = client;
_ssl.SetReadAhead(1);
// Buggy SSL versions have issue with compression and dtls
_ssl.SetOptions((int) SslOptions.SSL_OP_NO_COMPRESSION);
if(client) {
_ssl.SetConnectState();
} else {
_ssl.SetAcceptState();
}
// The ssl object will take control
_read = BIO.MemoryBuffer(false);
_read.NonBlocking = true;
_write = BIO.MemoryBuffer(false);
_write.NonBlocking = true;
_ssl.SetBIO(_read, _write);
_ssl.DoHandshake();
_buffer = new byte[Int16.MaxValue];
_buffer_sync = new object();
_fe_lock = 0;
}
void AddAccount(ISender sender, ArgumentList args)
{
if (!Storage.IsAvailable)
throw new CommandError("No permissions plugin or data plugin is attached");
var a = 0;
string name, pass;
APIAccount acc = null;
//api addaccount "username" "password"
if (!args.TryGetString(a++, out name))
throw new CommandError("Expected username after addaccount");
if (!args.TryGetString(a++, out pass))
throw new CommandError("Expected password after username");
acc = APIAccountManager.FindByName(name);
if (acc == null)
{
acc = APIAccountManager.Create(name, pass);
if (acc.Id > 0)
{
sender.SendMessage("Successfully created account.", R: 0, B: 0);
}
else
{
sender.SendMessage("Failed to create account.", G: 0, B: 0);
}
}
else
{
throw new CommandError("Existing API account found by " + name);
}
}
// Provides a method for local apps to add certificates to Brunet without
// being loaded with Brunet.
public void HandleRpc(ISender caller, string method, IList args, object rs)
{
object result = null;
try {
if(method.Equals("AddCertificate")) {
ReqrepManager.ReplyState rqrs = caller as ReqrepManager.ReplyState;
if(rqrs == null || !(rqrs.ReturnPath is Node)) {
throw new Exception("Call must be made locally for security reasons!");
}
string path = (string) args[0];
result = _ch.AddCertificate(path);
} else if(method.Equals("GetState")) {
if(args.Count != 1) {
throw new Exception("Not enough arguments");
} else if(!(args[0] is string)) {
throw new Exception("Argument should be a string");
}
Address addr = AddressParser.Parse(args[0] as string);
SecurityAssociation sa = CheckForSecureSender(addr);
if(sa == null) {
result = "No SA";
} else {
result = sa.ToString();
}
} else {
result = new Exception("Invalid method");
}
} catch (Exception e) {
result = e;
}
_node.Rpc.SendResult(rs, result);
}
public void HandleData(MemBlock packet, ISender from, object node)
{
_message_count++;
long stop_time, rt_ticks = -10000;
if ( !from.Equals(node)) {
if (packet[0] == 0) {
//log.Debug("Echo Response:");
stop_time = System.DateTime.Now.Ticks;
int received_uid = NumberSerializer.ReadInt(packet, 1);
if(uid_starttime.ContainsKey(received_uid)){
rt_ticks = stop_time - (long)EchoTester.uid_starttime[received_uid];
}
double rt_ms = (double) rt_ticks/10000.0;
uid_brunetpingtime.Add(received_uid, rt_ms);
Console.WriteLine("Packet ID = {0}, Round-trip = {1}", received_uid, rt_ms);
}
else {
//log.Debug("Echo Request:");
}
//log.Debug(packet.ToString());
//System.Console.WriteLine("{0}", packet.ToString());
if (packet[0] > 0) {
//Send a reply back, this is a request
byte[] new_payload = new byte[ packet.Length ];
packet.CopyTo(new_payload, 0);
new_payload[0] = (byte) 0;
from.Send(new CopyList(PType.Protocol.Echo, MemBlock.Reference(new_payload)));
}
}
}
public InstructionPacketSetID(byte servoId, byte newId, ISender sender)
: base(servoId, sender)
{
_instruction = 0x03;
_lengthOfCommand = 0x04;
_parameters.AddRange(new[] { (byte)0x03, newId });
}
private void WhoAmI(ISender sender, string args)
{
var player = sender as Player;
if (player != null)
{
var sb = new StringBuilder();
sb.Append("You are ");
if (!player.IsAuthenticated()) sb.Append("not ");
if (player.Op) sb.Append("an operator");
else sb.Append("logged in");
var groupName = String.Empty;
if (Storage.IsAvailable)
{
var grp = Storage.GetInheritedGroup(player);
if (grp != null) groupName = grp.Name;
}
if (!String.IsNullOrEmpty(groupName))
{
sb.Append(" and are a part of the ");
sb.Append(groupName);
sb.Append(" group");
}
else sb.Append(" but not apart of any groups");
sb.Append(".");
sender.Message(sb.ToString(), Color.Orange);
}
else sender.Message("This command is for players only", Color.Red);
}
/// <summary>
/// Enables or disables NPC spawning
/// </summary>
/// <param name="sender">Sending player</param>
/// <param name="args">Arguments sent with command</param>
public void NPCSpawning(ISender sender, ArgumentList args)
{
args.ParseNone();
Core.StopNPCSpawning = !Core.StopNPCSpawning;
sender.Message("NPC spawning is now " + (Core.StopNPCSpawning ? "off" : "on") + "!");
}
public static void ExampleCommand(ISender sender, ArgumentList args)
{
TDSM_Plugin MyPlugin = (TDSM_Plugin)args.Plugin; //Get the plugin object who's assigned to the "tdsmpluginexample"
int arg;
//if the user enters /tdsmpluginexample -test 1, it will retreive the next value '1' and put into 'arg' as an integer.
if (args.TryParseOne<int>("-test", out arg))
{
sender.sendMessage(sender.Name + " Argument: " + arg);
}
else
{
//For new people, I would not really expect you to understand the following.
//If needed I can simplify this down...
string Platform = Terraria_Server.Definitions.Platform.Type.ToString();
switch (Terraria_Server.Definitions.Platform.Type)
{
case Terraria_Server.Definitions.Platform.PlatformType.LINUX:
Platform = "Linux";
break;
case Terraria_Server.Definitions.Platform.PlatformType.MAC:
Platform = "Mac";
break;
case Terraria_Server.Definitions.Platform.PlatformType.WINDOWS:
Platform = "Windows";
break;
}
(sender as Player).sendMessage("TDSM Plugin Example, Running OS: " + Platform, ChatColor.DarkGreen);
}
}
void PasswordCommand(ISender sender, ArgumentList args)
{
Player player = sender as Player;
Protection temp = new Protection ();
Pair<Action, Protection> pair = new Pair<Action, Protection> (Action.NOTHING, null);
if (args.Count != 1) {
player.SendMessage ("Usage: /cpassword <password>", 255, 255, 0, 0);
return;
}
string Extra = args[0];
temp = new Protection ();
temp.Owner = player.Name;
temp.Type = Protection.PASSWORD_PROTECTION;
temp.Data = SHA1.Hash (Extra);
char[] pass = Extra.ToCharArray ();
for (int index = 0; index < pass.Length; index++) {
pass [index] = '*';
}
pair.First = Action.CREATE;
pair.Second = temp;
player.SendMessage ("Password: "******"Open the chest to protect it!", 255, 0, 255, 0);
// cache the action if it's not null!
if (pair.First != Action.NOTHING) {
ResetActions (player);
Cache.Actions.Add (player.Name, pair);
}
}
public static void roll(Server server, ISender sender, ArgumentList args)
{
Random random = new Random();
int result = 0;
int times = 1;
int die = 6;
if (args.Count > 0)
{
string[] arg = args[0].Split('d');
times = Int32.Parse(arg[0]);
die = Int32.Parse(arg[1]);
}
for (int i = 0; i < times; i++)
{
result += random.Next(1, die);
}
Player player = server.GetPlayerByName(sender.Name);
if (! player.PluginData.ContainsKey("roll"))
{
player.PluginData.Add("roll", result);
}
else
{
player.PluginData["roll"] = result;
}
server.notifyAll(player.Name + " rolled a " + player.PluginData["roll"] + " on " + times.ToString() + "d" + die.ToString(), true);
}
override public void Invoke(ISender target, Channel q, string method,
params object[] args)
{
IRpcHandler handler = null;
string mname = null;
lock( _sync ) {
object[] info = (object[]) _method_cache[method];
if( info == null ) {
string[] parts = method.Split('.');
string hname = parts[0];
mname = parts[1];
handler = (IRpcHandler)_method_handlers[ hname ];
if( handler == null ) {
//No handler for this.
throw new AdrException(-32601, "No Handler for method: " + method);
}
info = new object[2];
info[0] = handler;
info[1] = mname;
_method_cache[ method ] = info;
}
else {
handler = (IRpcHandler)info[0];
mname = (string)info[1];
}
}
handler.HandleRpc(target, mname, args, q);
}
/// <summary>
/// Refreshes a players area
/// </summary>
/// <param name="sender">Sending player</param>
/// <param name="args">Arguments sent with command</param>
public void Refresh(ISender sender, ArgumentList args)
{
args.ParseNone();
var player = sender as Player;
if (player == null)
{
sender.Message(255, "This is a player command");
return;
}
if (player.whoAmI < 0)
return;
if (!player.Op)
{
var diff = DateTime.Now - player.GetLastCostlyCommand();
if (diff < TimeSpan.FromSeconds(30))
{
sender.Message(255, "You must wait {0:0} more seconds before using this command.", 30.0 - diff.TotalSeconds);
return;
}
player.SetLastCostlyCommand(DateTime.Now);
}
NetMessage.SendTileSquare(player.whoAmI, (int)(player.position.X / 16), (int)(player.position.Y / 16), 32);
}
/// <summary>
/// Fast forwards time
/// </summary>
/// <param name="sender">Sending player</param>
/// <param name="args">Arguments sent with command</param>
public void FastForwardTime(ISender sender, ArgumentList args)
{
args.ParseNone();
Core.TimeFastForwarding = !Core.TimeFastForwarding;
sender.Message("Time is now " + (Core.TimeFastForwarding ? "fast" : "normal") + "!");
}
//TODO sort commands in alphabetical order.
/// <summary>
/// Shuts down an exists.
/// </summary>
/// <param name="sender">Sending entity</param>
/// <param name="args">Arguments sent with command</param>
public static void Clear(ISender sender, ArgumentList args)
{
if (sender is ConsoleSender)
{
Console.Clear();
}
}
/// <summary>
/// Allows users to log in.
/// </summary>
/// <param name="sender">Sending player</param>
/// <param name="password">Password for verification</param>
public void Auth(ISender sender, string password)
{
if (sender is Player)
{
var player = sender as Player;
if (Storage.IsAvailable)
{
var existing = Authentication.GetPlayer(sender.SenderName);
if (existing != null)
{
if (existing.ComparePassword(sender.SenderName, password))
{
Utils.NotifyAllOps(
String.Format("{0} successfully logged in.", player.name)
);
player.SendMessage("Successfully logged in.", Color.DarkGreen);
player.SetAuthentication(sender.SenderName, "tdsm");
player.SetOp(existing.Operator);
}
else
{
sender.Message("Login failed", Color.DarkRed);
}
}
else
{
sender.Message("Login failed", Color.DarkRed);
}
}
else
sender.Message("This function is unavailable", Color.DarkRed);
}
}
public void Subscribe(ISender sender)
{
sender.MessageAvailable += (o, args) =>
{
ReceivedMessage = args.Message;
};
}
/// <summary>
/// Prints a player list, Possibly readable by bots.
/// </summary>
/// <param name="sender">Sending player</param>
/// <param name="args">Arguments sent with command</param>
public void List(ISender sender, ArgumentList args)
{
args.ParseNone();
var players = from p in Terraria.Main.player
where p.active && !p.IsOp()
select p.name;
var ops = from p in Terraria.Main.player
where p.active && p.IsOp()
select p.name;
var pn = players.Count();
var on = ops.Count();
if (on + pn == 0)
{
sender.Message("No players online.");
return;
}
string ps = String.Empty;
string os = String.Empty;
if (pn > 0)
ps = (on > 0 ? " | Players: " : "Players: ") + String.Join(", ", players);
if (on > 0)
os = "Ops: " + String.Join(", ", ops);
sender.SendMessage(string.Concat(os, ps, " (", on + pn, "/", Netplay.MaxConnections, ")"), 255, 255, 240, 20);
}
public RequestCommand(ISender sender)
{
if (sender == null)
throw new ArgumentNullException("sender");
this.sender = sender;
}
/// <summary>
/// Teleports specified player to sending player's location.
/// </summary>
/// <param name="sender">Sending player</param>
/// <param name="args">Arguments sent with command</param>
public void TeleportHere(ISender sender, ArgumentList args)
{
if (sender is Player)
{
Player player = ((Player)sender);
Player subject;
if (args.TryPopOne(out subject))
{
if (subject == null)
{
sender.Message("Cannot find player");
return;
}
subject.Teleport(player);
Utils.NotifyAllOps("Teleported " + subject.name + " to " +
player.name + " [" + sender.SenderName + "]", true);
}
}
else
{
throw new CommandError("This command is for players only");
}
}
/// <summary>
/// Bans a user from the server.
/// </summary>
/// <param name="sender">Sending entity</param>
/// <param name="args">Arguments sent with command</param>
public static void Ban(ISender sender, string player)
{
if (sender is ConsoleSender)
{
if (String.IsNullOrEmpty(player))
{
Tools.WriteLine("Usage: ban <player>");
}
else
{
bool found = false;
var lowered = player.ToLower();
for (int i = 0; i < 255; i++)
{
if (Main.player[i].active && Main.player[i].name.ToLower() == lowered)
{
Callbacks.NetplayCallback.AddBan(i);
NetMessage.SendData(2, i, -1, "Banned from server.", 0, 0f, 0f, 0f, 0);
found = true;
}
}
if (!found) sender.Message("Failed to find a player by the name of {0}", player);
}
}
}
/// <summary>
/// Heals one or all players.
/// </summary>
/// <param name="sender">Sending player</param>
/// <param name="message">Message to send</param>
public void Heal(ISender sender, ArgumentList args)
{
Player subject;
if (args.TryPopOne(out subject))
{
subject = sender as Player;
if (subject == null)
{
sender.Message("Need a heal target");
return;
}
NetMessage.SendData((int)Packet.HEAL_PLAYER, -1, -1, String.Empty, subject.whoAmI, (float)subject.statLifeMax);
subject.Message("You have been healed!", Color.Green);
}
else if (args.TryPop("-all"))
{
foreach (var plr in Main.player)
{
if (plr.active)
{
NetMessage.SendData((int)Packet.HEAL_PLAYER, -1, -1, String.Empty, plr.whoAmI, (float)plr.statLifeMax);
plr.Message("You have been healed!", Color.Green);
}
}
}
else if (sender is Player)
{
var plr = sender as Player;
NetMessage.SendData((int)Packet.HEAL_PLAYER, -1, -1, String.Empty, plr.whoAmI, (float)plr.statLifeMax);
plr.Message("You have been healed!", Color.Green);
}
else throw new CommandError("Nobody specified to heal");
}
public static void ExampleCommand(ISender sender, ArgumentList args)
{
TDSM_Plugin MyPlugin = (TDSM_Plugin)args.Plugin; //Get the plugin object who's assigned to the "tdsmpluginexample"
//if the user enters /tdsmpluginexample -test 1, it will retreive the next value '1' and put into 'arg' as an integer.
int arg;
if (args.TryParseOne<int>("-test", out arg))
sender.sendMessage(sender.Name + " Argument: " + arg);
else
{
//For new people to .NET, I would not really expect you to understand everything just yet.
string platform = Platform.Type.ToString();
switch (Platform.Type)
{
case Platform.PlatformType.LINUX:
platform = "Linux";
break;
case Platform.PlatformType.MAC:
platform = "Mac";
break;
case Platform.PlatformType.WINDOWS:
platform = "Windows";
break;
}
(sender as Player).sendMessage("TDSM Plugin Example, Running OS: " + platform, ChatColor.DarkGreen);
}
}
public void HandleRpc(ISender caller, string method, IList args, object rs)
{
if (LocalUseOnly)
{
try {
ReqrepManager.ReplyState _rs = (ReqrepManager.ReplyState)caller;
Node node = (Node)_rs.ReturnPath;
if (node != _node)
{
throw new Exception();
}
} catch {
AdrException e = new AdrException(-32602, new Exception("Must send from local node!"));
_node.Rpc.SendResult(rs, e);
return;
}
}
object result = null;
try {
switch (method)
{
case "Create":
{
// Needs to be Async so we don't deadlock!
MemBlock key = MemBlock.Reference((byte[])args[0]);
MemBlock value = MemBlock.Reference((byte[])args[1]);
int ttl = (int)args[2];
Channel returns = new Channel(1);
returns.CloseEvent += delegate(object o, EventArgs eargs) {
_node.Rpc.SendResult(rs, returns.Dequeue());
};
_dht.AsyncCreate(key, value, ttl, returns);
return;
}
case "Put":
{
// Needs to be Async so we don't deadlock!
MemBlock key = MemBlock.Reference((byte[])args[0]);
MemBlock value = MemBlock.Reference((byte[])args[1]);
int ttl = (int)args[2];
Channel returns = new Channel(1);
returns.CloseEvent += delegate(object o, EventArgs eargs) {
_node.Rpc.SendResult(rs, returns.Dequeue());
};
_dht.AsyncPut(key, value, ttl, returns);
return;
}
case "Get":
{
// Needs to be Async so we don't deadlock!
MemBlock key = MemBlock.Reference((byte[])args[0]);
Channel returns = new Channel();
returns.CloseEvent += delegate(object o, EventArgs eargs) {
Hashtable [] results = new Hashtable[returns.Count];
int pos = 0;
while (returns.Count > 0)
{
results[pos++] = (Hashtable)returns.Dequeue();
}
_node.Rpc.SendResult(rs, results);
};
_dht.AsyncGet(key, returns);
return;
}
case "BeginGet":
{
MemBlock key = MemBlock.Reference((byte[])args[0]);
result = BeginGet(key);
break;
}
case "ContinueGet":
{
MemBlock token = MemBlock.Reference((byte[])args[0]);
ContinueGet(token, rs);
return;
}
case "EndGet":
{
MemBlock token = MemBlock.Reference((byte[])args[0]);
EndGet(token);
result = true;
break;
}
}
} catch (Exception e) {
result = new AdrException(-32602, e);
}
_node.Rpc.SendResult(rs, result);
}
public BucketVariableProvider(ISender sender, IDocumentSerializer documentSerializer)
{
_sender = sender;
_documentSerializer = documentSerializer;
}
public MediaLinkMessageReceiver(ISender sender)
{
_sender = sender;
}
public TalkBack(ISender sender)
{
this.sender = sender;
}
public GamesController(ISender sender)
{
_sender = sender;
}
public PlainTextMessageReceiver(ISender sender, Settings settings)
{
_sender = sender;
_settings = settings;
}
virtual public void HandleData(MemBlock b, ISender return_path, object state)
{
Handle(b, return_path);
}
public void UnregisterSender(ISender sender)
{
senderList.Remove(sender);
}
/**
* This starts a linking operation on the given edge
*/
public IDictionary Start(IDictionary link_message, ISender edge)
{
if (ProtocolLog.LinkDebug.Enabled)
{
ProtocolLog.Write(ProtocolLog.LinkDebug, String.Format(
"{0} -start- sys:link.Start", _node.Address));
}
Edge from = GetEdge(edge);
LinkMessage lm = new LinkMessage(link_message);
if (ProtocolLog.LinkDebug.Enabled)
{
ProtocolLog.Write(ProtocolLog.LinkDebug, String.Format(
"{0} -args- sys:link.Start({1},{2})", _node.Address, lm, from));
}
CphState cph = new CphState(from, lm);
lock ( _sync ) {
if (!_edge_to_cphstate.ContainsKey(from))
{
_edge_to_cphstate[from] = cph;
}
else
{
throw new AdrException((int)ErrorMessage.ErrorCode.InProgress,
"Already have a link in progress on this edge");
}
}
ErrorMessage err = null;
if (CanConnect(cph, out err))
{
try {
//If the CloseEvent was already called, this throws an exception
from.CloseEvent += this.CloseHandler;
}
catch {
CloseHandler(from, null);
throw new AdrException((int)ErrorMessage.ErrorCode.EdgeClosed,
"Edge Closed after receiving message");
}
}
else
{
lock ( _sync ) {
_edge_to_cphstate.Remove(from);
}
}
//Now we prepare our response
LinkMessage lm_resp = null;
if (err == null)
{
//We send a response:
NodeInfo n_info = NodeInfo.CreateInstance(_node.Address, from.LocalTA);
NodeInfo remote_info = NodeInfo.CreateInstance(null, from.RemoteTA);
lm_resp = new LinkMessage(lm.ConTypeString, n_info, remote_info, _node.Realm, lm.Token);
}
else
{
if (err.Ec == ErrorMessage.ErrorCode.AlreadyConnected)
{
/**
* When we send the ErrorCode.AlreadyConnected,
* we could have a stale connection, lets try pinging
* the other node, if they are there, but have lost
* the Edge, this may trigger the edge to close, causing
* us to remove the Connection.
* @todo consider putting this address on a "fast track"
* to removal if we don't hear from it soon
*/
ConnectionTable tab = _node.ConnectionTable;
Connection c = tab.GetConnection(lm.ConnectionType,
lm.Local.Address);
if (c != null)
{
RpcManager rpc = _node.Rpc;
rpc.Invoke(c.Edge, null, "sys:link.Ping", String.Empty);
}
}
}
if (err != null)
{
throw new AdrException((int)err.Ec, err.Message);
}
if (ProtocolLog.LinkDebug.Enabled)
{
ProtocolLog.Write(ProtocolLog.LinkDebug, String.Format(
"{0} -end- sys:link.Start()->{1}", _node.Address, lm_resp));
}
return(lm_resp.ToDictionary());
}
/**
* Get a StatusMessage for this node
*/
public IDictionary GetStatus(IDictionary status_message, ISender edge)
{
//we just got s status request
if (1 == _disconnecting)
{
throw new AdrException((int)ErrorMessage.ErrorCode.Disconnecting, "disconnecting");
}
StatusMessage sm = new StatusMessage(status_message);
Edge from = GetEdge(edge);
if (ProtocolLog.LinkDebug.Enabled)
{
ProtocolLog.Write(ProtocolLog.LinkDebug, String.Format(
"{0} -start- sys:link.GetStatus({1},{2})", _node.Address, sm, edge));
}
CphState cphstate = null;
if (from != null)
{
cphstate = _edge_to_cphstate[from] as CphState;
}
/**
* StatusMessage objects are used to verify the completion
* of the Link protocol. If we receive a StatusMessage request
* after we send a LinkMessage response, we know the other
* Node got our LinkMessage response, and the connection
* is active
*/
StatusMessage response = null;
ConnectionTable tab = _node.ConnectionTable;
if (cphstate != null)
{
try {
LinkMessage lm_to_add = cphstate.LM;
//This is part of connection process:
response = _node.GetStatus(sm.NeighborType, lm_to_add.Local.Address);
Connection con = new Connection(from,
lm_to_add.Local.Address,
lm_to_add.ConTypeString,
sm,
lm_to_add);
tab.Add(con);
}
finally {
from.CloseEvent -= this.CloseHandler;
CloseHandler(from, null);
}
}
else
{
//This is just a "regular" status request
//update our table:
Address fadd = null;
Connection c = tab.GetConnection(from);
if (c != null)
{
fadd = c.Address;
tab.UpdateStatus(c, sm);
}
response = _node.GetStatus(sm.NeighborType, fadd);
}
if (ProtocolLog.LinkDebug.Enabled)
{
ProtocolLog.Write(ProtocolLog.LinkDebug, String.Format(
"{0} -end- sys:link.GetStatus()->{1}", _node.Address, response));
}
return(response.ToDictionary());
}
public AuthorizationController(ISender mediator)
{
_mediator = mediator;
}
public OptionNativeContentReceiver(ISender sender)
{
_sender = sender;
}
private LoginApi(ISender sender) : base(ID, sender)
{
}
public static LoginApi Create(ISender sender) => new LoginApi(sender);
public PlaybackController(ISender parent)
{
this.parent = parent;
}
private void ProcessFirstUpdate(ISender sender)
{
var data = Repository.GetAllData().Select(c => c.Data).ToList();
sender.Update(data);
}
/// <summary>
/// Creates a new email instance with overrides for the rendering and sending engines.
/// </summary>
/// <param name="renderer">The template rendering engine</param>
/// <param name="sender">The email sending implementation</param>
public Email(ITemplateRenderer renderer, ISender sender)
: this(renderer, sender, null, null)
{
}
/// <inheritdoc /> public override bool CanExecuteFrom(ISender sender) => _client.Equals(sender);
public void Setup(INodeParameters _nodeParameters, ILogger _logger)
{
variable = new Variable().Set(null as object);
sender = _nodeParameters.GetSender();
_nodeParameters.AddOutput(true, "Object", "Unity collision object");
}
public void Setup(INodeParameters _node, ILogger _logger)
{
_node.AddInput(this, true, "a");
sender = _node.GetSender();
_node.AddOutput(false, "Closest power of two");
}
public ClientsController(ISender sender)
{
fSender = sender;
}
public LightweightSendingAgent(Uri destination, ISender sender, CompositeTransportLogger logger, BusSettings settings)
: base(destination, sender, logger, settings, new LightweightRetryAgent(sender, settings.Retries))
{
}
public URLPrefixSender(string urlPrefix, ISender inner)
{
this.urlPrefix = urlPrefix;
this.inner = inner;
}
/** Handle incoming data on an Edge
*/
public void HandleData(MemBlock data, ISender retpath, object state)
{
MemBlock rest_of_data;
PType p;
if (state == null)
{
try {
p = PType.Parse(data, out rest_of_data);
} catch (ParseException) {
ProtocolLog.WriteIf(ProtocolLog.Pathing, "Invalid PType from: " + data);
return;
}
p = PType.Parse(data, out rest_of_data);
}
else
{
//a demux has already happened:
p = (PType)state;
rest_of_data = data;
}
if (PType.Protocol.Pathing.Equals(p))
{
/*
* We use a special PType to denote this transaction so
* we don't confuse it with other RepRep communication
*/
_rrm.HandleData(rest_of_data, retpath, null);
}
else if (PType.Protocol.Rpc.Equals(p))
{
/*
* Send this to the RpcHandler
*/
Rpc.HandleData(rest_of_data, retpath, null);
}
else
{
/*
* This is some other data
* It is either:
* 1) Time to announce an already created edge.
* 2) Assume this is a "default path" edge creation, to be backwards
* compatible
*/
Edge e = null;
PathEdge pe = null;
try {
e = (Edge)retpath;
PathEdgeListener pel = null;
lock ( _sync ) {
if (_unannounced.TryGetValue(e, out pe))
{
//
_unannounced.Remove(e);
pel = _pel_map[pe.LocalPath];
}
}
if (pe == null)
{
if (!_pel_map.ContainsKey(Root))
{
ProtocolLog.WriteIf(ProtocolLog.Pathing, "No root, can't create edge");
if (e != null)
{
e.Close();
}
return;
}
/*
* This must be a "default path" incoming connection
*/
pel = _pel_map[Root];
pe = new PathEdge(this, e, Root, Root);
}
pel.SendPathEdgeEvent(pe);
pe.Subscribe();
pe.ReceivedPacketEvent(data);
}
catch (Exception x) {
if (pe != null)
{
//This closes both edges:
pe.Close();
}
else if (e != null)
{
ProtocolLog.WriteIf(ProtocolLog.Pathing,
String.Format("Closing ({0}) due to: {1}", e, x));
e.Close();
}
}
}
}
protected void HandleReply(ReqrepType rt, int idnum, MemBlock rest, ISender ret_path)
{
RequestState reqs;
if (_req_state_table.TryGet(idnum, out reqs))
{
IReplyHandler handler = null;
lock ( _sync ) {
if (reqs.AddReplier(ret_path))
{
TimeSpan rtt = DateTime.UtcNow - reqs.ReqDate;
/*
* Let's look at how long it took to get this reply:
*/
if (reqs.GotAck)
{
//Use more standard deviations for acked messages. We
//just don't want to let it run forever.
_acked_reqtimeout = ComputeNewTimeOut(rtt.TotalMilliseconds,
_acked_rtt_stats,
_MINIMUM_TIMEOUT, 3 * _STD_DEVS);
}
else if (ret_path is Edge)
{
_edge_reqtimeout = ComputeNewTimeOut(rtt.TotalMilliseconds,
_edge_rtt_stats,
_MINIMUM_TIMEOUT, _STD_DEVS);
}
else
{
_nonedge_reqtimeout = ComputeNewTimeOut(rtt.TotalMilliseconds,
_nonedge_rtt_stats, _MINIMUM_TIMEOUT, _STD_DEVS);
}
handler = reqs.ReplyHandler;
}
}
/*
* Now handle this reply
*/
if (null != handler)
{
MemBlock payload;
PType pt = PType.Parse(rest, out payload);
Statistics statistics = new Statistics();
statistics.SendCount = reqs.SendCount;
#if REQREP_DEBUG
Console.Error.WriteLine("[ReqrepManager: {0}] Receiving reply on request id: {1}, from: {2}",
_info, idnum, ret_path);
#endif
//Don't hold the lock while calling the ReplyHandler:
bool continue_listening = handler.HandleReply(this, rt, idnum, pt, payload,
ret_path, statistics, reqs.UserState);
//the request has been served
if (!continue_listening)
{
StopRequest(idnum, handler);
}
}
}
else
{
//We are ignoring this reply, it either makes no sense, or we have
//already handled it
}
}
/// <param name="sender">The ISender that will take care of the actual sending as well as storing the items to be sent</param>
/// <param name="serialization">The object that is used to serialize the spans into Thrift</param>
protected internal JaegerThriftTransport(ISender sender, ISerialization serialization = null)
{
_sender = sender;
_jaegerThriftSerialization = serialization ?? new JaegerThriftSerialization();
}
public static SenderRet Send(ISender sender, PushChannelModel channel, PushMsgModel msg)
{
return(sender.Send(channel, msg));
}
public Client(ISender sender, ISerializer serializer)
{
this.sender = sender;
this.serializer = serializer;
}
public static SenderRet Send(ISender sender, PushChannelModel channel, List <PushMsgModel> msgList)
{
return(sender.SendList(channel, msgList));
}
private void Execute(ISender client, GetStartupItemsResponse message)
{
OnReport(message.StartupItems);
}
