public PyObject Encode() { if (cache == null) { Log.Error("PyCachedObject", "Cache data is null"); return null; } if (objectID == null) { Log.Error("PyCachedObject", "objectID is null"); return null; } PyTuple args = new PyTuple(); PyTuple versiont = new PyTuple(); versiont.Items.Add(new PyLongLong(timestamp)); versiont.Items.Add(new PyInt(version)); args.Items.Add(versiont); args.Items.Add(new PyNone()); args.Items.Add(new PyInt(nodeID)); args.Items.Add(new PyInt(shared)); args.Items.Add(cache); args.Items.Add(new PyInt(compressed)); args.Items.Add(objectID); return new PyObjectData("objectCaching.CachedObject", args); }
public void TestStringIsTupleType() { using (Py.GIL()) { var s = new PyString("foo"); Assert.IsFalse(PyTuple.IsTupleType(s)); } }
public void TestPyTupleEmpty() { using (Py.GIL()) { var t = new PyTuple(); Assert.AreEqual(0, t.Length()); } }
public void SendServiceCall(int characterID, string service, string call, PyTuple args, PyDictionary namedPayload, Action <RemoteCall, PyDataType> callback, Action <RemoteCall> timeoutCallback = null, object extraInfo = null, int timeoutSeconds = 0) { this.ClientSendServiceCall( this.AccountDB.GetAccountIDFromCharacterID(characterID), service, call, args, namedPayload, callback, timeoutCallback, extraInfo, timeoutSeconds ); }
public void TupleMarshal_Empty() { PyTuple tuple = new PyTuple(0); byte[] output = Marshal.Marshal.ToByteArray(tuple, false); Assert.AreEqual(sTupleMarshaling_Empty, output); }
public void TestPyTupleIsTupleType() { using (Py.GIL()) { var t = new PyTuple(); Assert.IsTrue(PyTuple.IsTupleType(t)); } }
public override PyInteger MachoResolveObject(PyTuple objectData, PyInteger zero, CallInformation call) { /* * [0] => alliance or corp id * [1] => is master */ return(this.BoundServiceManager.Container.NodeID); }
public PyObject Encode() { PyTuple packet = new PyTuple(); packet.Items.Add(new PyInt(nodeID)); packet.Items.Add(solarSystems); return new PyObjectData("machoNet.nodeInfo", packet); }
public PyDataType BeanCount(PyInteger stackID, PyDictionary namedPayload, object client) { PyTuple res = new PyTuple(2); res[0] = new PyNone(); res[1] = new PyInteger(0); return(res); }
public PyDataType BeanCount(PyInteger stackID, CallInformation call) { PyTuple res = new PyTuple(2); res[0] = new PyNone(); res[1] = new PyInteger(0); return(res); }
public PyObject Encode() { PyTuple header = new PyTuple(); header.Items.Add(new PyToken("blue.DBRowDescriptor")); header.Items.Add(columnList); return(new PyObjectEx(false, header)); }
/* This should never be used in the node, just the Cache Tool */ public bool Decode(PyObject from) { PyTuple data = (from as PyObjectData).Arguments as PyTuple; // Just decode the cache info for now.. cache = data.Items[4] as PyBuffer; return(true); }
public void AddColumn(string name, FieldType type) { PyTuple column = new PyTuple(); column.Items.Add(new PyString(name)); column.Items.Add(new PyInt((int)type)); ColumnList.Items.Add(column); }
public void TestPyTupleInvalidAppend() { using (Py.GIL()) { PyObject s = new PyString("foo"); var t = new PyTuple(); Assert.Throws <PythonException>(() => t.Concat(s)); } }
public PyObject Encode() { PyTuple args = new PyTuple(); args.Items.Add(session); args.Items.Add(new PyInt(clientID)); return(new PyObjectData("macho.sessionInitialState", args)); }
public PyObject BeanCount(PyTuple args, object client) { PyTuple res = new PyTuple(); res.Items.Add(new PyNone()); // Unique error ID, None for instant stack trace res.Items.Add(new PyInt(0)); // logging mode, 0 = local return(res); }
public Sequential(params PythonObject[] modules) : base() { var nn = self.GetAttr("nn"); var __self__ = nn; var pyargs = new PyTuple(modules.Select(m => m.PyObject as PyObject).ToArray()); dynamic py = __self__.InvokeMethod("Sequential", pyargs); self = py as PyObject; }
public PyObject Encode() { PyTuple header = new PyTuple(); header.Items.Add(new PyToken("blue.DBRowDescriptor")); header.Items.Add(columnList); return new PyObjectEx(false, header); }
public void AddColumn(string name, FieldType type) { PyTuple column = new PyTuple(); column.Items.Add(new PyString(name)); column.Items.Add(new PyInt((int)type)); columnList.Items.Add(column); }
public PyObject Encode() { PyTuple packet = new PyTuple(); packet.Items.Add(new PyInt(nodeID)); packet.Items.Add(solarSystems); return(new PyObjectData("machoNet.nodeInfo", packet)); }
public PyObject Call(string svc, string call, PyTuple args, object client) { Service service = GetService(svc); if (service == null) return null; return service.Call(call, args, client); }
private IntPtr HandleLog(IntPtr self, IntPtr args) { var tup = new PyTuple(args); if (tup.IsInvalid || !tup.IsTuple || tup.Size <= 0) return PyObject.None; var obj = tup[0]; Core.Log(LogSeverity.Minor, obj.ToString()); return PyObject.None; }
public PyObject BeanCount(PyTuple args, object client) { PyTuple res = new PyTuple(); res.Items.Add(new PyNone()); // Unique error ID, None for instant stack trace res.Items.Add(new PyInt(0)); // logging mode, 0 = local return res; }
public bool CheckLowLevelVersionExchange(PyTuple packet) { LowLevelVersionExchange data = new LowLevelVersionExchange(); if (data.Decode(packet) == false) { Log.Error("Client", "Wrong LowLevelVersionExchange packet"); return(false); } if (data.birthday != Common.Constants.Game.birthday) { Log.Error("Client", "Wrong birthday in LowLevelVersionExchange"); return(false); } if (data.build != Common.Constants.Game.build) { Log.Error("Client", "Wrong build in LowLevelVersionExchange"); return(false); } if (data.codename != Common.Constants.Game.codename + "@" + Common.Constants.Game.region) { Log.Error("Client", "Wrong codename in LowLevelVersionExchange"); return(false); } if (data.machoVersion != Common.Constants.Game.machoVersion) { Log.Error("Client", "Wrong machoVersion in LowLevelVersionExchange"); return(false); } if (data.version != Common.Constants.Game.version) { Log.Error("Client", "Wrong version in LowLevelVersionExchange"); return(false); } if (data.isNode == true) { if (data.nodeIdentifier != "Node") { Log.Error("Client", "Wrong node string in LowLevelVersionExchange"); return(false); } Type = ConnectionType.Node; } else { Type = ConnectionType.Client; } return(true); }
public PyObject Encode() { PyTuple args = new PyTuple(); args.Items.Add(session); args.Items.Add(new PyInt(clientID)); return new PyObjectData("macho.sessionInitialState", args); }
public void VargsKeywordDefaults() { var co = new CodeObject(new byte[0]); co.ArgCount = 0; co.Defaults = new List <object>(); co.VarNames.Add("args"); co.VarNames.Add("a"); co.VarNames.Add("b"); co.Defaults = new List <object>(); co.KWDefaults = new List <object>(); co.KWDefaults.Add(3); co.KWDefaults.Add(4); co.KWOnlyArgCount = 2; co.Flags |= CodeObject.CO_FLAGS_VARGS; var inputs = new object[][] { new object[] { 1, 2 }, new object[] { 1, 2 }, new object[] { 1, 2 }, new object[] { 1, 2 }, new object[] { }, new object[] { }, }; var keywordsIn = new Dictionary <string, object>[] { new Dictionary <string, object> { }, new Dictionary <string, object> { { "a", 200 }, { "b", 100 } }, new Dictionary <string, object> { { "a", 200 }, }, new Dictionary <string, object> { { "b", 100 }, }, new Dictionary <string, object> { { "a", 200 }, }, new Dictionary <string, object> { }, }; var outputs = new object[][] { new object[] { PyTuple.Create(new object[] { 1, 2 }), 3, 4 }, new object[] { PyTuple.Create(new object[] { 1, 2 }), 200, 100 }, new object[] { PyTuple.Create(new object[] { 1, 2 }), 200, 4 }, new object[] { PyTuple.Create(new object[] { 1, 2 }), 3, 100 }, new object[] { PyTuple.Create(new object[0]), 200, 4 }, new object[] { PyTuple.Create(new object[0]), 3, 4 }, }; InOutTest(co, inputs, keywordsIn, outputs); }
public UserError(PyTuple tuple, PyDict match) { if (match == null) { throw new InvalidDataException("UserError: No matching set found."); } if (tuple.Items.Count > 2 || tuple.Items.Count < 1) { throw new InvalidDataException("UserError: Invalid tuple size expected 1 or 2 got " + tuple.Items.Count); } PyString msgString = tuple.Items[0] as PyString; if (msgString == null) { throw new InvalidDataException("UserError: No message found."); } message = msgString.Value; if (tuple.Items.Count == 2) { dict = tuple.Items[1] as PyDict; if (dict == null) { throw new InvalidDataException("UserError: Invalid dictionary."); } } msgString = match.Get("msg") as PyString; if (msgString == null || msgString.StringValue != message) { throw new InvalidDataException("UserError: Message name mismatch."); } PyRep matchRep = match.Get("dict"); if (dict != null) { PyDict matchDict = matchRep as PyDict; if (matchDict == null) { throw new InvalidDataException("UserError: No matching dictionary."); } if (matchDict.Dictionary.Count != dict.Dictionary.Count) { throw new InvalidDataException("UserError: Dictionary size mismatch."); } //foreach(var kvp in dict.Dictionary) //{ // To-DO: compare each entry. //} } else { if (matchRep != null && !(matchRep is PyNone)) { throw new InvalidDataException("UserError: No Dictionary to match."); } } }
public void TupleUnmarshal_Empty() { PyDataType value = Unmarshal.ReadFromByteArray(sTupleMarshaling_Empty, false); Assert.IsInstanceOf <PyTuple>(value); PyTuple tuple = value as PyTuple; Assert.AreEqual(0, tuple.Count); }
public PyPacket() { type = Macho.MachoNetMsg_Type.__Fake_Invalid_Type; type_string = "none"; userID = 0; payload = null; named_payload = null; source = new PyAddress(); dest = new PyAddress(); }
public void TestPyTupleValidConvert() { using (Py.GIL()) { var l = new PyList(); PyTuple t = PyTuple.AsTuple(l); Assert.IsNotNull(t); Assert.IsInstanceOf(typeof(PyTuple), t); } }
public void TestPyTupleBadCtor() { var i = new PyInt(5); PyTuple t = null; var ex = Assert.Throws <ArgumentException>(() => t = new PyTuple(i)); Assert.AreEqual("object is not a tuple", ex.Message); Assert.IsNull(t); }
private IntPtr ReadDataPort(IntPtr self, IntPtr args) { var argTuple = new PyTuple(new PyObject(args, false)); var portName = argTuple.Get(0).GetString(); var dataPort = InputPorts.First(port => port.Name == portName) as NodeSystemLib2.FormatData1D.InputPortData1D; var buffer = dataPort.Read(); return(new PyArray(buffer.Data.Take(buffer.Available).ToArray(), false).Object.Handle); }
public void TestPyTupleValidAppend() { var t0 = new PyTuple(); var t = new PyTuple(); t.Concat(t0); Assert.IsNotNull(t); Assert.IsInstanceOf(typeof(PyTuple), t); }
public void NotifyCharacter(int characterID, string type, PyTuple notification) { // do not waste network resources on useless notifications if (this.CharacterManager.IsCharacterConnected(characterID) == false) { return; } this.SendNotification(type, NOTIFICATION_TYPE_CHARACTER, characterID, notification); }
public void TestInvalidAsTuple() { var i = new PyInt(5); PyTuple t = null; var ex = Assert.Throws <PythonException>(() => t = PyTuple.AsTuple(i)); Assert.AreEqual("'int' object is not iterable", ex.Message); Assert.IsNull(t); }
public DataType VisitTuple(PyTuple t) { TupleType tt = analyzer.TypeFactory.CreateTuple(); foreach (var e in t.values) { tt.add(e.Accept(this)); } return(tt); }
public void TestNewPyTupleFromPyTuple() { using (Py.GIL()) { var t0 = new PyTuple(); var t = new PyTuple(t0); Assert.IsNotNull(t); Assert.IsInstanceOf(typeof(PyTuple), t); } }
private void HandleNotification(PyPacket packet, Client client) { if (packet.Source is PyAddressAny) { this.HandleBroadcastNotification(packet); return; } PyTuple callInfo = ((packet.Payload[0] as PyTuple)[1] as PySubStream).Stream as PyTuple; PyList objectIDs = callInfo[0] as PyList; string call = callInfo[1] as PyString; if (call != "ClientHasReleasedTheseObjects") { Log.Error($"Received notification from client with unknown method {call}"); return; } // search for the given objects in the bound service // and sure they're freed foreach (PyTuple objectID in objectIDs.GetEnumerable <PyTuple>()) { if (objectID[0] is PyString == false) { Log.Fatal("Expected bound call with bound string, but got something different"); return; } string boundString = objectID[0] as PyString; // parse the bound string to get back proper node and bound ids Match regexMatch = Regex.Match(boundString, "N=([0-9]+):([0-9]+)"); if (regexMatch.Groups.Count != 3) { Log.Fatal($"Cannot find nodeID and boundID in the boundString {boundString}"); return; } int nodeID = int.Parse(regexMatch.Groups[1].Value); int boundID = int.Parse(regexMatch.Groups[2].Value); if (nodeID != this.Container.NodeID) { Log.Fatal("Got a ClientHasReleasedTheseObjects call for an object ID that doesn't belong to us"); // TODO: MIGHT BE A GOOD IDEA TO RELAY THIS CALL TO THE CORRECT NODE // TODO: INSIDE THE NETWORK, AT LEAST THAT'S WHAT CCP IS DOING BASED // TODO: ON THE CLIENT'S CODE... NEEDS MORE INVESTIGATION return; } this.BoundServiceManager.FreeBoundService(boundID); } }
public PyObject Call(string name, PyTuple args, object client) { ServiceCall call = GetServiceCall(name); if (call == null) { return new PyTuple(); } return call.Run(args, client); }
public void TestPyTupleStringConvert() { PyObject s = new PyString("foo"); PyTuple t = PyTuple.AsTuple(s); Assert.IsNotNull(t); Assert.IsInstanceOf(typeof(PyTuple), t); Assert.AreEqual("f", t[0].ToString()); Assert.AreEqual("o", t[1].ToString()); Assert.AreEqual("o", t[2].ToString()); }
public PyObject Encode() { PyTuple res = new PyTuple(); PyTuple main = new PyTuple(); main.Items.Add(new PyInt(clueless)); main.Items.Add(changes); res.Items.Add(main); res.Items.Add(nodesOfInterest); return res.As<PyObject>(); }
public PyObject Encode() { PyTuple args = new PyTuple(); args.Items.Add(new PyToken("dbutil.CRowset")); PyDict dict = new PyDict(); dict.Set("header", descriptor.Encode()); PyObjectEx res = new PyObjectEx(); res.IsType2 = true; args.Items.Add(dict); res.List = items.Items; return res; }
public PyDict EncodeChanges() { PyDict res = new PyDict(); PyDict tmp = new PyDict(); // Iterate through the session data foreach (PyString s in session.Dictionary.Keys) { PyTuple value = session[s].As<PyTuple>(); PyObject last = value.Items[0]; PyObject current = value.Items[1]; // Check if they have the same type and value if (last != current) { // Add the change to the dict PyTuple change = new PyTuple(); change.Items.Add(last); change.Items.Add(current); res.Set(s.Value, change); // Update the session with the new last value PyTuple update = new PyTuple(); update.Items.Add(current); update.Items.Add(current); // We cant modify the session here, just store it on something temporal tmp[s] = update; } else { // We havent updated anything, but this would be later set as the session // This will prevent the loss of session data tmp[s] = value; } } // Send back the session from temporal to the final storage session = tmp; return res; }
public static PyTuple GetCacheData(string name) { MySqlDataReader res = null; if (Database.Query(ref res, "SELECT cacheData, cacheTime, nodeID, version FROM cacheinfo WHERE cacheName='" + name + "';") == false) { return null; } if (res == null) { return null; } if (res.Read() == false) { res.Close(); return null; } byte[] outb = null; try { outb = (byte[])res.GetValue(0); } catch (Exception) { Log.Error("CacheDB", "Cannot get cache data for cache " + name); res.Close(); return null; } PyTuple tup = new PyTuple(); tup.Items.Add(new PyBuffer(outb)); tup.Items.Add(new PyLongLong(res.GetInt64(1))); tup.Items.Add(new PyIntegerVar(res.GetInt32(2))); tup.Items.Add(new PyIntegerVar(res.GetUInt32(3))); res.Close(); return tup; }
public override PyObject Run(PyTuple args, object client) { Log.Debug("objectCaching", "Called GetCachableObject stub"); CacheInfo cache = new CacheInfo(); if (cache.Decode(args) == false) { return null; } Log.Debug("GetCachableObject", "Got cache request for cache " + cache.objectID.As<PyString>().Value); if (Cache.LoadCacheFor(cache.objectID.As<PyString>().Value) == false) { return null; } return Cache.GetCache(cache.objectID.As<PyString>().Value); }
// Who said me that this was painfull? :D Oh wait, It was me... // Nevermind, forget that, I found a way of do this using reflection // So this will be faster and painless public PyObject ServiceCall(string service, string call, PyTuple data, object client) { MethodInfo method = GetType().GetMethod(service); if (method == null) { throw new ServiceDoesNotExistsException(service); } Service svc = (Service)(method.Invoke(this, null)); method = svc.GetType().GetMethod(call); if (method == null) { throw new ServiceDoesNotContainCallException(service, call); } return (PyObject)(method.Invoke(svc, new object[] { data, client })); }
public PyObject SendClientStackTraceAlert(PyTuple args, object client) { Log.Trace("SendClientStackTraceAlert", "Received client stack trace. Saving to a file"); try { if (File.Exists("logs/stacktrace.txt") == false) { File.Create("logs/stacktrace.txt"); } File.AppendAllText("logs/stacktrace.txt", "------------------ " + args.Items[2].StringValue + " ------------------\n"); File.AppendAllText("logs/stacktrace.txt", args.Items[0].As<PyTuple>().Items[1].StringValue); File.AppendAllText("logs/stacktrace.txt", args.Items[1].StringValue + "\n"); } catch (Exception) { } // The client should receive anything to know that the stack trace arrived to the server return new PyNone(); }
public PyObject Encode() { PyTuple args = new PyTuple(); // Command args.Items.Add(new PyInt((int)type)); // Source args.Items.Add(source.Encode()); // Dest args.Items.Add(dest.Encode()); // unknown if (userID == 0) args.Items.Add(new PyNone()); else args.Items.Add(new PyInt((int)userID)); // Add call args( payload ) args.Items.Add(payload); // Named arguments if (named_payload == null) args.Items.Add(new PyNone()); else args.Items.Add(named_payload); return new PyObjectData(type_string, args); }
private static string PrintTuple(PyTuple tuple) { return "[PyTuple " + tuple.Items.Count + " items]"; }
public PyObject Encode() { PyTuple header = new PyTuple(); PyTuple args = new PyTuple(); PyToken exception = new PyToken(exception_type); PyDict keywords = new PyDict(); args.Items.Add(new PyString(reason)); keywords.Set("reasonArgs", reasonArgs); keywords.Set("clock", new PyLongLong(clock)); keywords.Set("region", new PyString(region)); keywords.Set("reason", new PyString(reason)); keywords.Set("version", new PyFloat(version)); keywords.Set("build", new PyInt(build)); keywords.Set("codename", new PyString(codename)); keywords.Set("machoVersion", new PyInt(machoVersion)); header.Items.Add(exception); header.Items.Add(args); header.Items.Add(keywords); return new PyObjectEx(false, header); }
public static PyObject DBResultToTupleSet(ref MySqlDataReader result) { int column = result.FieldCount; if (column == 0) return new PyTuple(); int r = 0; PyTuple res = new PyTuple(); PyList cols = new PyList(); PyList reslist = new PyList(); for (r = 0; r < column; r++) { cols.Items.Add(new PyString(result.GetName(r))); } while (result.Read()) { PyList linedata = new PyList(); for (r = 0; r < column; r++) { linedata.Items.Add(DBColumnToPyObject(r, ref result)); } reslist.Items.Add(linedata); } res.Items.Add(cols); res.Items.Add(reslist); return res; }
/* From client/script/common/net/machonet.py line: 3864 * Client = ('clientID', 'callID', 'service') * Broadcast = ('broadcastID', 'narrowcast', 'idtype') * Node = ('nodeID', 'service', 'callID') * Any = ('service', 'callID') */ public PyObject Encode() { PyTuple t = new PyTuple(); switch (type) { case AddrType.Any: t.Items.Add( new PyString( "A" )); if( service == "" ) t.Items.Add( new PyNone() ); else t.Items.Add( new PyString( service ) ); if( typeID == 0 ) t.Items.Add(new PyNone()); else t.Items.Add(new PyLongLong( (long)typeID ) ); break; case AddrType.Node: t.Items.Add( new PyString( "N" ) ); t.Items.Add( new PyLongLong( (long)typeID ) ); if( service == "" ) t.Items.Add( new PyNone() ); else t.Items.Add( new PyString( service ) ); if( callID == 0 ) t.Items.Add( new PyNone() ); else t.Items.Add( new PyLongLong( (long)callID ) ); break; case AddrType.Client: t.Items.Add( new PyString( "C" ) ); t.Items.Add(new PyLongLong((long)typeID)); t.Items.Add(new PyLongLong((long)callID)); if( service == "" ) t.Items.Add( new PyNone() ); else t.Items.Add( new PyString( service ) ); break; case AddrType.Broadcast: t.Items.Add( new PyString( "B" ) ); if( service == "" ) t.Items.Add( new PyNone() ); else t.Items.Add( new PyString( service ) ); t.Items.Add( new PyList() ); t.Items.Add( new PyString( bcast_type ) ); break; default: break; } return new PyObjectData( "macho.MachoAddress", t ); }
public static void HeartbeatNodes() { // Check if an older heartbeat left a node waiting foreach (int nodeID in nodeStatus.Keys) { if (nodes[nodeID] == null) { continue; } if (nodeStatus[nodeID] == NodeStatus.NodeWaitingHeartbeat) { // Node dead, load all the solarSystems into other node and transfer the clients try { nodes.Remove(nodeID); } catch (Exception) { } } } PyTuple data = new PyTuple(); data.Items.Add(new PyLongLong(DateTime.Now.ToFileTime())); NotifyNodes(new PyObjectData("macho.PingReq", data)); }
public PyObject GetInitVals(PyTuple args, object client) { Log.Debug("machoNet", "Called GetInitVals stub"); if (Cache.LoadCacheFor("machoNet.serviceInfo") == false) { // Cache does not exists, create it PyDict dict = new PyDict(); dict.Set("trademgr", new PyString("station")); dict.Set("tutorialSvc", new PyString("station")); dict.Set("bookmark", new PyString("station")); dict.Set("slash", new PyString("station")); dict.Set("wormholeMgr", new PyString("station")); dict.Set("account", new PyString("station")); dict.Set("gangSvc", new PyString("station")); dict.Set("contractMgr", new PyString("station")); dict.Set("LSC", new PyString("location")); dict.Set("station", new PyString("location")); dict.Set("config", new PyString("locationPreferred")); dict.Set("scanMgr", new PyString("solarsystem")); dict.Set("keeper", new PyString("solarsystem")); dict.Set("stationSvc", new PyNone()); dict.Set("zsystem", new PyNone()); dict.Set("invbroker", new PyNone()); dict.Set("droneMgr", new PyNone()); dict.Set("userSvc", new PyNone()); dict.Set("map", new PyNone()); dict.Set("beyonce", new PyNone()); dict.Set("standing2", new PyNone()); dict.Set("ram", new PyNone()); dict.Set("DB", new PyNone()); dict.Set("posMgr", new PyNone()); dict.Set("voucher", new PyNone()); dict.Set("entity", new PyNone()); dict.Set("damageTracker", new PyNone()); dict.Set("agentMgr", new PyNone()); dict.Set("dogmaIM", new PyNone()); dict.Set("machoNet", new PyNone()); dict.Set("dungeonExplorationMgr", new PyNone()); dict.Set("watchdog", new PyNone()); dict.Set("ship", new PyNone()); dict.Set("DB2", new PyNone()); dict.Set("market", new PyNone()); dict.Set("dungeon", new PyNone()); dict.Set("npcSvc", new PyNone()); dict.Set("sessionMgr", new PyNone()); dict.Set("allianceRegistry", new PyNone()); dict.Set("cache", new PyNone()); dict.Set("character", new PyNone()); dict.Set("factory", new PyNone()); dict.Set("facWarMgr", new PyNone()); dict.Set("corpStationMgr", new PyNone()); dict.Set("authentication", new PyNone()); dict.Set("effectCompiler", new PyNone()); dict.Set("charmgr", new PyNone()); dict.Set("BSD", new PyNone()); dict.Set("reprocessingSvc", new PyNone()); dict.Set("billingMgr", new PyNone()); dict.Set("billMgr", new PyNone()); dict.Set("lookupSvc", new PyNone()); dict.Set("emailreader", new PyNone()); dict.Set("lootSvc", new PyNone()); dict.Set("http", new PyNone()); dict.Set("repairSvc", new PyNone()); dict.Set("gagger", new PyNone()); dict.Set("dataconfig", new PyNone()); dict.Set("lien", new PyNone()); dict.Set("i2", new PyNone()); dict.Set("pathfinder", new PyNone()); dict.Set("alert", new PyNone()); dict.Set("director", new PyNone()); dict.Set("dogma", new PyNone()); dict.Set("aggressionMgr", new PyNone()); dict.Set("corporationSvc", new PyNone()); dict.Set("certificateMgr", new PyNone()); dict.Set("clones", new PyNone()); dict.Set("jumpCloneSvc", new PyNone()); dict.Set("insuranceSvc", new PyNone()); dict.Set("corpmgr", new PyNone()); dict.Set("warRegistry", new PyNone()); dict.Set("corpRegistry", new PyNone()); dict.Set("objectCaching", new PyNone()); dict.Set("counter", new PyNone()); dict.Set("petitioner", new PyNone()); dict.Set("LPSvc", new PyNone()); dict.Set("clientStatsMgr", new PyNone()); dict.Set("jumpbeaconsvc", new PyNone()); dict.Set("debug", new PyNone()); dict.Set("languageSvc", new PyNone()); dict.Set("skillMgr", new PyNone()); dict.Set("voiceMgr", new PyNone()); dict.Set("onlineStatus", new PyNone()); dict.Set("gangSvcObjectHandler", new PyNone()); Cache.SaveCacheFor("machoNet.serviceInfo", dict, DateTime.Now.ToFileTimeUtc()); } PyObject srvInfo = Cache.GetCacheData("machoNet.serviceInfo"); PyTuple res = new PyTuple(); PyDict initvals = new PyDict(); res.Items.Add(srvInfo); res.Items.Add(initvals); // Rest of the cache data return res; }
public PyObject GetTime(PyTuple args, object client) { return new PyLongLong(DateTime.Now.ToFileTimeUtc()); }
private IntPtr HandleTest(IntPtr self, IntPtr args) { Core.Log(LogSeverity.Minor, "In HandleTest"); var tup = new PyTuple(args); foreach (var obj in tup) Core.Log(LogSeverity.Minor, "arg: " + obj); return new PyInt(1).Pointer; }
//raise_stmt: 'raise' [test ['from' test]] //raise_stmt: 'raise' [test [',' test [',' Test]]] public Statement raise_stmt() { Exp exToRaise = null; Exp exOriginal = null; var token = Expect(TokenType.Raise); var posStart = token.Start; var posEnd = token.End; if (!Peek(stmt_follow)) { exToRaise = test(); posEnd = exToRaise.End; if (PeekAndDiscard(TokenType.From)) { exOriginal = test(); posEnd = exOriginal.End; } else if (PeekAndDiscard(TokenType.COMMA)) { Exp ex2 = test(); Exp ex3 = new NoneExp(filename, ex2.End, ex2.End); if (PeekAndDiscard(TokenType.COMMA)) { ex3 = test(); } exOriginal = new PyTuple(new List<Exp> { ex2, ex3 }, filename, posStart, (ex3 ?? ex2).End); posEnd = exOriginal.End; } } return new RaiseStatement(exToRaise, exOriginal, filename, posStart, posEnd); }
public void VisitTuple(PyTuple tuple) { throw new NotImplementedException(); }
public bool Decode( PyObject data ) { PyObject packet = data; if (packet.Type == PyObjectType.ChecksumedStream) { packet = packet.As<PyChecksumedStream>().Data; } if (packet.Type == PyObjectType.SubStream) { packet = packet.As<PySubStream>().Data; } if (packet.Type != PyObjectType.ObjectData) { return false; } PyObjectData packeto = packet.As<PyObjectData>(); type_string = packeto.Name; if (packeto.Arguments.Type != PyObjectType.Tuple) { return false; } PyTuple tuple = packeto.Arguments.As<PyTuple>(); if (tuple.Items.Count != 6) { return false; } if ((tuple.Items[0].Type != PyObjectType.IntegerVar) && ( tuple.Items[0].Type != PyObjectType.Long ) ) { return false; } PyInt typer = tuple.Items[0].As<PyInt>(); type = (Macho.MachoNetMsg_Type)typer.Value; if (!source.Decode(tuple.Items[1])) { return false; } if (!dest.Decode(tuple.Items[2])) { return false; } if ((tuple.Items[3].Type == PyObjectType.IntegerVar) || (tuple.Items[3].Type == PyObjectType.Long) ) { userID = (uint)tuple.Items[3].As<PyInt>().Value; } else if (tuple.Items[3].Type == PyObjectType.None) { userID = 0; } else { return false; } // Payload( or call arguments ) if ((tuple.Items[4].Type != PyObjectType.Buffer) && (tuple.Items[4].Type != PyObjectType.Tuple)) { return false; } payload = tuple.Items[4].As<PyTuple>(); if (tuple.Items[5].Type == PyObjectType.None) { named_payload = new PyDict(); } else if (tuple.Items[5].Type == PyObjectType.Dict) { named_payload = tuple.Items[5].As<PyDict>(); } else { return false; } return true; }
private void _Set(PyObject key, PyObject val) { if (session.Dictionary.ContainsKey(key) == false) { PyTuple var = new PyTuple(); var.Items.Add(new PyNone()); var.Items.Add(val); session.Dictionary.Add(key, var); } else { PyTuple tmp = session.Dictionary[key].As<PyTuple>(); tmp.Items[0] = tmp.Items[1]; tmp.Items[1] = val; session.Dictionary[key] = tmp; } }