Changeset 332


Ignore:
Timestamp:
Nov 16, 2018, 10:38:46 PM (11 months ago)
Author:
alloc
Message:

*Latest optimizations

Location:
binary-improvements
Files:
17 edited

Legend:

Unmodified
Added
Removed
  • binary-improvements/7dtd-server-fixes/src/PersistentData/Players.cs

    r327 r332  
    66        [Serializable]
    77        public class Players {
    8                 private readonly Dictionary<string, Player> players = new Dictionary<string, Player> (StringComparer.OrdinalIgnoreCase);
     8                public readonly Dictionary<string, Player> Dict = new Dictionary<string, Player> (StringComparer.OrdinalIgnoreCase);
    99
    1010                public Player this [string steamId, bool create] {
     
    1414                                }
    1515
    16                                 if (players.ContainsKey (steamId)) {
    17                                         return players [steamId];
     16                                if (Dict.ContainsKey (steamId)) {
     17                                        return Dict [steamId];
    1818                                }
    1919
     
    2424                                Log.Out ("Created new player entry for ID: " + steamId);
    2525                                Player p = new Player (steamId);
    26                                 players.Add (steamId, p);
     26                                Dict.Add (steamId, p);
    2727                                return p;
    2828                        }
    2929                }
    3030
    31                 public List<string> SteamIDs {
    32                         get { return new List<string> (players.Keys); }
    33                 }
    34 
    3531                public int Count {
    36                         get { return players.Count; }
     32                        get { return Dict.Count; }
    3733                }
    3834
     
    5854                        int entityId;
    5955                        if (int.TryParse (_nameOrId, out entityId)) {
    60                                 foreach (KeyValuePair<string, Player> kvp in players) {
     56                                foreach (KeyValuePair<string, Player> kvp in Dict) {
    6157                                        if (kvp.Value.IsOnline && kvp.Value.EntityID == entityId) {
    6258                                                return kvp.Key;
     
    6561                        }
    6662
    67                         foreach (KeyValuePair<string, Player> kvp in players) {
     63                        foreach (KeyValuePair<string, Player> kvp in Dict) {
    6864                                string name = kvp.Value.Name;
    6965                                if (_ignoreColorCodes) {
  • binary-improvements/AllocsCommands/Commands/ListKnownPlayers.cs

    r326 r332  
    6262                                } else {
    6363                                        int num = 0;
    64                                         foreach (string sid in PersistentContainer.Instance.Players.SteamIDs) {
    65                                                 Player p = PersistentContainer.Instance.Players [sid, false];
     64                                        foreach (KeyValuePair<string, Player> kvp in PersistentContainer.Instance.Players.Dict) {
     65                                                Player p = kvp.Value;
    6666
    6767                                                if (
    6868                                                        (!onlineOnly || p.IsOnline)
    69                                                         && (!notBannedOnly || !admTools.IsBanned (sid))
     69                                                        && (!notBannedOnly || !admTools.IsBanned (kvp.Key))
    7070                                                        && (nameFilter.Length == 0 || p.Name.ContainsCaseInsensitive (nameFilter))
    7171                                                ) {
    7272                                                        SdtdConsole.Instance.Output (string.Format (
    7373                                                                "{0}. {1}, id={2}, steamid={3}, online={4}, ip={5}, playtime={6} m, seen={7}",
    74                                                                 ++num, p.Name, p.EntityID, sid, p.IsOnline, p.IP,
     74                                                                ++num, p.Name, p.EntityID, kvp.Key, p.IsOnline, p.IP,
    7575                                                                p.TotalPlayTime / 60,
    7676                                                                p.LastOnline.ToString ("yyyy-MM-dd HH:mm"))
  • binary-improvements/MapRendering/MapRendering/MapRenderBlockBuffer.cs

    r331 r332  
    1717                private Vector2i currentBlockMapPos = new Vector2i (Int32.MinValue, Int32.MinValue);
    1818                private string currentBlockMapFolder = string.Empty;
    19                 private string currentBlockMapFilename = string.Empty;
    2019
    2120                public MapRenderBlockBuffer (int level, MapTileCache cache) {
     
    4645                public void ResetBlock () {
    4746                        currentBlockMapFolder = string.Empty;
    48                         currentBlockMapFilename = string.Empty;
    4947                        currentBlockMapPos = new Vector2i (Int32.MinValue, Int32.MinValue);
    5048                }
     
    8482                                        currentBlockMapFolder = folder;
    8583                                        currentBlockMapPos = block;
    86                                         currentBlockMapFilename = fileName;
    8784
    8885                                        Profiler.EndSample ();
  • binary-improvements/MapRendering/Web/API/GetLandClaims.cs

    r326 r332  
    2121
    2222                        // default user, cheap way to avoid 'null reference exception'
    23                         user = user ?? new WebConnection ("", "", 0L);
     23                        user = user ?? new WebConnection ("", IPAddress.None, 0L);
    2424
    2525                        bool bViewAll = WebConnection.CanViewAllClaims (permissionLevel);
  • binary-improvements/MapRendering/Web/API/GetPlayerInventories.cs

    r325 r332  
     1using System.Collections.Generic;
    12using System.Net;
    23using AllocsFixes.JSON;
     
    910                        JSONArray AllInventoriesResult = new JSONArray ();
    1011
    11                         foreach (string sid in PersistentContainer.Instance.Players.SteamIDs) {
    12                                 Player p = PersistentContainer.Instance.Players [sid, false];
     12                        foreach (KeyValuePair<string, Player> kvp in PersistentContainer.Instance.Players.Dict) {
     13                                Player p = kvp.Value;
    1314
    1415                                if (p == null) {
     
    2324                                        JSONArray belt = new JSONArray ();
    2425                                        JSONObject equipment = new JSONObject ();
    25                                         result.Add ("steamid", new JSONString (sid));
     26                                        result.Add ("steamid", new JSONString (kvp.Key));
    2627                                        result.Add ("entityid", new JSONNumber (p.EntityID));
    2728                                        result.Add ("playername", new JSONString (p.Name));
  • binary-improvements/MapRendering/Web/API/GetPlayerList.cs

    r326 r332  
    66using AllocsFixes.JSON;
    77using AllocsFixes.PersistentData;
     8using UnityEngine.Profiling;
    89
    910namespace AllocsFixes.NetConnections.Servers.Web.API {
     
    1213                        new Regex (@"^(>=|=>|>|<=|=<|<|==|=)?\s*([0-9]+(\.[0-9]*)?)$");
    1314
     15#if ENABLE_PROFILER
     16                private static readonly CustomSampler jsonSerializeSampler = CustomSampler.Create ("JSON_Build");
     17#endif
     18
    1419                public override void HandleRequest (HttpListenerRequest req, HttpListenerResponse resp, WebConnection user,
    1520                        int permissionLevel) {
    1621                        AdminTools admTools = GameManager.Instance.adminTools;
    17                         user = user ?? new WebConnection ("", "", 0L);
     22                        user = user ?? new WebConnection ("", IPAddress.None, 0L);
    1823
    1924                        bool bViewAll = WebConnection.CanViewAllPlayers (permissionLevel);
     
    3540                        Players playersList = PersistentContainer.Instance.Players;
    3641
     42                       
    3743                        List<JSONObject> playerList = new List<JSONObject> ();
    3844
    39                         foreach (string sid in playersList.SteamIDs) {
    40                                 Player p = playersList [sid, false];
     45#if ENABLE_PROFILER
     46                        jsonSerializeSampler.Begin ();
     47#endif
     48
     49                        foreach (KeyValuePair<string, Player> kvp in playersList.Dict) {
     50                                Player p = kvp.Value;
    4151
    4252                                ulong player_steam_ID;
    43                                 if (!ulong.TryParse (sid, out player_steam_ID)) {
     53                                if (!ulong.TryParse (kvp.Key, out player_steam_ID)) {
    4454                                        player_steam_ID = 0L;
    4555                                }
     
    5262
    5363                                        JSONObject pJson = new JSONObject ();
    54                                         pJson.Add ("steamid", new JSONString (sid));
     64                                        pJson.Add ("steamid", new JSONString (kvp.Key));
    5565                                        pJson.Add ("entityid", new JSONNumber (p.EntityID));
    5666                                        pJson.Add ("ip", new JSONString (p.IP));
     
    6676                                        JSONBoolean banned;
    6777                                        if (admTools != null) {
    68                                                 banned = new JSONBoolean (admTools.IsBanned (sid));
     78                                                banned = new JSONBoolean (admTools.IsBanned (kvp.Key));
    6979                                        } else {
    7080                                                banned = new JSONBoolean (false);
     
    7686                                }
    7787                        }
     88
     89#if ENABLE_PROFILER
     90                        jsonSerializeSampler.End ();
     91#endif
    7892
    7993                        IEnumerable<JSONObject> list = playerList;
  • binary-improvements/MapRendering/Web/API/GetPlayersLocation.cs

    r326 r332  
     1using System.Collections.Generic;
    12using System.Net;
    23using AllocsFixes.JSON;
     
    89                        int permissionLevel) {
    910                        AdminTools admTools = GameManager.Instance.adminTools;
    10                         user = user ?? new WebConnection ("", "", 0L);
     11                        user = user ?? new WebConnection ("", IPAddress.None, 0L);
    1112
    1213                        bool listOffline = false;
     
    2122                        Players playersList = PersistentContainer.Instance.Players;
    2223
    23                         foreach (string sid in playersList.SteamIDs) {
     24                        foreach (KeyValuePair<string, Player> kvp in playersList.Dict) {
    2425                                if (admTools != null) {
    25                                         if (admTools.IsBanned (sid)) {
     26                                        if (admTools.IsBanned (kvp.Key)) {
    2627                                                continue;
    2728                                        }
    2829                                }
    2930
    30                                 Player p = playersList [sid, false];
     31                                Player p = kvp.Value;
    3132
    3233                                if (listOffline || p.IsOnline) {
    3334                                        ulong player_steam_ID;
    34                                         if (!ulong.TryParse (sid, out player_steam_ID)) {
     35                                        if (!ulong.TryParse (kvp.Key, out player_steam_ID)) {
    3536                                                player_steam_ID = 0L;
    3637                                        }
     
    4344
    4445                                                JSONObject pJson = new JSONObject ();
    45                                                 pJson.Add ("steamid", new JSONString (sid));
     46                                                pJson.Add ("steamid", new JSONString (kvp.Key));
    4647
    4748                                                //                                      pJson.Add("entityid", new JSONNumber (p.EntityID));
  • binary-improvements/MapRendering/Web/API/WebAPI.cs

    r326 r332  
    22using System.Text;
    33using AllocsFixes.JSON;
     4using UnityEngine.Profiling;
    45
    56namespace AllocsFixes.NetConnections.Servers.Web.API {
     
    1112                }
    1213
     14#if ENABLE_PROFILER
     15                private static readonly CustomSampler jsonSerializeSampler = CustomSampler.Create ("JSON_Serialize");
     16                private static readonly CustomSampler netWriteSampler = CustomSampler.Create ("JSON_Write");
     17#endif
     18
    1319                public static void WriteJSON (HttpListenerResponse resp, JSONNode root) {
     20#if ENABLE_PROFILER
     21                        jsonSerializeSampler.Begin ();
     22#endif
    1423                        StringBuilder sb = new StringBuilder ();
    1524                        root.ToString (sb);
     25#if ENABLE_PROFILER
     26                        jsonSerializeSampler.End ();
     27                        netWriteSampler.Begin ();
     28#endif
    1629                        byte[] buf = Encoding.UTF8.GetBytes (sb.ToString ());
    1730                        resp.ContentLength64 = buf.Length;
     
    1932                        resp.ContentEncoding = Encoding.UTF8;
    2033                        resp.OutputStream.Write (buf, 0, buf.Length);
     34#if ENABLE_PROFILER
     35                        netWriteSampler.End ();
     36#endif
    2137                }
    2238
  • binary-improvements/MapRendering/Web/ConnectionHandler.cs

    r326 r332  
    11using System;
    22using System.Collections.Generic;
     3using System.Net;
    34
    45namespace AllocsFixes.NetConnections.Servers.Web {
     
    67                private readonly Dictionary<string, WebConnection> connections = new Dictionary<string, WebConnection> ();
    78
    8                 public WebConnection IsLoggedIn (string _sessionId, string _endpoint) {
     9                public WebConnection IsLoggedIn (string _sessionId, IPAddress _ip) {
    910                        if (!connections.ContainsKey (_sessionId)) {
    1011                                return null;
     
    1819//                      }
    1920
    20                         if (con.Endpoint != _endpoint) {
    21                                 connections.Remove (_sessionId);
     21                        if (!Equals (con.Endpoint, _ip)) {
     22                                // Fixed: Allow different clients from same NAT network
     23//                              connections.Remove (_sessionId);
    2224                                return null;
    2325                        }
     
    3234                }
    3335
    34                 public WebConnection LogIn (ulong _steamId, string _endpoint) {
     36                public WebConnection LogIn (ulong _steamId, IPAddress _ip) {
    3537                        string sessionId = Guid.NewGuid ().ToString ();
    36                         WebConnection con = new WebConnection (sessionId, _endpoint, _steamId);
     38                        WebConnection con = new WebConnection (sessionId, _ip, _steamId);
    3739                        connections.Add (sessionId, con);
    3840                        return con;
     
    4042
    4143                public void SendLine (string line) {
    42                         foreach (WebConnection wc in connections.Values) {
    43                                 wc.SendLine (line);
     44                        foreach (KeyValuePair<string, WebConnection> kvp in connections) {
     45                                kvp.Value.SendLine (line);
    4446                        }
    4547                }
  • binary-improvements/MapRendering/Web/Handlers/ApiHandler.cs

    r326 r332  
    44using System.Reflection;
    55using AllocsFixes.NetConnections.Servers.Web.API;
     6using UnityEngine.Profiling;
    67
    78namespace AllocsFixes.NetConnections.Servers.Web.Handlers {
     
    4041                }
    4142
     43#if ENABLE_PROFILER
     44                private static readonly CustomSampler apiHandlerSampler = CustomSampler.Create ("API_Handler");
     45#endif
     46
    4247                public override void HandleRequest (HttpListenerRequest req, HttpListenerResponse resp, WebConnection user,
    4348                        int permissionLevel) {
     
    5560                        if (apis.TryGetValue (apiName, out api)) {
    5661                                try {
     62#if ENABLE_PROFILER
     63                                        apiHandlerSampler.Begin ();
     64#endif
    5765                                        api.HandleRequest (req, resp, user, permissionLevel);
     66#if ENABLE_PROFILER
     67                                        apiHandlerSampler.End ();
     68#endif
    5869                                        return;
    5970                                } catch (Exception e) {
  • binary-improvements/MapRendering/Web/Handlers/StaticHandler.cs

    r325 r332  
    1313                        string moduleName = null) : base (moduleName) {
    1414                        this.staticPart = staticPart;
    15                         datapath = filePath;
     15                        datapath = filePath + (filePath [filePath.Length - 1] == '/' ? "" : "/");
    1616                        this.cache = cache;
    1717                        this.logMissingFiles = logMissingFiles;
     
    2222                        string fn = req.Url.AbsolutePath.Remove (0, staticPart.Length);
    2323
    24                         byte[] content = cache.GetFileContent (datapath + "/" + fn);
     24                        byte[] content = cache.GetFileContent (datapath + fn);
    2525
    2626                        if (content != null) {
     
    3131                                resp.StatusCode = (int) HttpStatusCode.NotFound;
    3232                                if (logMissingFiles) {
    33                                         Log.Out ("Web:Static:FileNotFound: \"" + req.Url.AbsolutePath + "\" @ \"" + datapath + "/" +
    34                                                  req.Url.AbsolutePath.Remove (0, staticPart.Length) + "\"");
     33                                        Log.Out ("Web:Static:FileNotFound: \"" + req.Url.AbsolutePath + "\" @ \"" + datapath + fn + "\"");
    3534                                }
    3635                        }
  • binary-improvements/MapRendering/Web/Handlers/UserStatusHandler.cs

    r325 r332  
    1919                                JSONObject permObj = new JSONObject ();
    2020                                permObj.Add ("module", new JSONString (perm.module));
    21                                 permObj.Add ("allowed",
    22                                         new JSONBoolean (WebPermissions.Instance.ModuleAllowedWithLevel (perm.module, permissionLevel)));
     21                                permObj.Add ("allowed", new JSONBoolean (perm.permissionLevel >= permissionLevel));
    2322                                perms.Add (permObj);
    2423                        }
  • binary-improvements/MapRendering/Web/MimeType.cs

    r325 r332  
    55        public class MimeType {
    66                private static readonly IDictionary<string, string> _mappings =
    7                         new Dictionary<string, string> (StringComparer.InvariantCultureIgnoreCase) {
     7                        new CaseInsensitiveStringDictionary<string> {
    88                                {".323", "text/h323"},
    99                                {".3g2", "video/3gpp2"},
  • binary-improvements/MapRendering/Web/Web.cs

    r326 r332  
    1010using AllocsFixes.NetConnections.Servers.Web.Handlers;
    1111using UnityEngine;
     12using UnityEngine.Profiling;
    1213
    1314namespace AllocsFixes.NetConnections.Servers.Web {
     
    1920                private readonly HttpListener _listener = new HttpListener ();
    2021                private readonly string dataFolder;
    21                 private readonly Dictionary<string, PathHandler> handlers = new Dictionary<string, PathHandler> ();
     22                private readonly Dictionary<string, PathHandler> handlers = new CaseInsensitiveStringDictionary<PathHandler> ();
    2223                private readonly bool useStaticCache;
    2324
     
    147148                        return false;
    148149                }
     150               
     151                private readonly Version HttpProtocolVersion = new Version(1, 1);
     152               
     153#if ENABLE_PROFILER
     154                private readonly CustomSampler authSampler = CustomSampler.Create ("Auth");
     155                private readonly CustomSampler handlerSampler = CustomSampler.Create ("Handler");
     156#endif
    149157
    150158                private void HandleRequest (IAsyncResult result) {
     
    157165
    158166//                              MicroStopwatch msw = new MicroStopwatch ();
     167#if ENABLE_PROFILER
     168                        Profiler.BeginThreadProfiling ("AllocsMods", "WebRequest");
     169                        HttpListenerContext ctx = _listener.EndGetContext (result);
     170                        try {
     171#else
    159172                        HttpListenerContext ctx = _listener.EndGetContext (result);
    160173                        _listener.BeginGetContext (HandleRequest, _listener);
     174#endif
    161175                        try {
    162176                                HttpListenerRequest request = ctx.Request;
     
    164178                                response.SendChunked = false;
    165179
    166                                 response.ProtocolVersion = new Version ("1.1");
     180                                response.ProtocolVersion = HttpProtocolVersion;
    167181
    168182                                WebConnection conn;
     183#if ENABLE_PROFILER
     184                                authSampler.Begin ();
     185#endif
    169186                                int permissionLevel = DoAuthentication (request, out conn);
     187#if ENABLE_PROFILER
     188                                authSampler.End ();
     189#endif
    170190
    171191
     
    200220                                                                }
    201221                                                        } else {
     222#if ENABLE_PROFILER
     223                                                                handlerSampler.Begin ();
     224#endif
    202225                                                                kvp.Value.HandleRequest (request, response, conn, permissionLevel);
     226#if ENABLE_PROFILER
     227                                                                handlerSampler.End ();
     228#endif
    203229                                                        }
    204230
     
    230256                                Interlocked.Decrement (ref currentHandlers);
    231257                        }
     258#if ENABLE_PROFILER
     259                        } finally {
     260                                _listener.BeginGetContext (HandleRequest, _listener);
     261                                Profiler.EndThreadProfiling ();
     262                        }
     263#endif
    232264                }
    233265
     
    241273
    242274                        if (!string.IsNullOrEmpty (sessionId)) {
    243                                 WebConnection con = connectionHandler.IsLoggedIn (sessionId, _req.RemoteEndPoint.Address.ToString ());
     275                                WebConnection con = connectionHandler.IsLoggedIn (sessionId, _req.RemoteEndPoint.Address);
    244276                                if (con != null) {
    245277                                        _con = con;
     
    259291                        }
    260292
    261                         if (_req.Url.AbsolutePath.StartsWith ("/session/verify")) {
     293                        if (_req.Url.AbsolutePath.StartsWith ("/session/verify", StringComparison.OrdinalIgnoreCase)) {
    262294                                try {
    263295                                        ulong id = OpenID.Validate (_req);
    264296                                        if (id > 0) {
    265                                                 WebConnection con = connectionHandler.LogIn (id, _req.RemoteEndPoint.Address.ToString ());
     297                                                WebConnection con = connectionHandler.LogIn (id, _req.RemoteEndPoint.Address);
    266298                                                _con = con;
    267299                                                int level = GameManager.Instance.adminTools.GetAdminToolsClientInfo (id.ToString ())
  • binary-improvements/MapRendering/Web/WebCommandResult.cs

    r325 r332  
    3939
    4040                public void SendLines (List<string> _output) {
    41                         MicroStopwatch msw = new MicroStopwatch ();
     41//                      MicroStopwatch msw = new MicroStopwatch ();
    4242
    4343                        StringBuilder sb = new StringBuilder ();
     
    8181                                }
    8282
    83                                 msw.Stop ();
    84                                 if (GamePrefs.GetInt (EnumGamePrefs.HideCommandExecutionLog) < 1) {
    85                                         totalHandlingTime += msw.ElapsedMicroseconds;
    86                                         Log.Out ("WebCommandResult.SendLines(): Took {0} µs", msw.ElapsedMicroseconds);
    87                                 }
     83//                              msw.Stop ();
     84//                              if (GamePrefs.GetInt (EnumGamePrefs.HideCommandExecutionLog) < 1) {
     85//                                      totalHandlingTime += msw.ElapsedMicroseconds;
     86//                                      Log.Out ("WebCommandResult.SendLines(): Took {0} µs", msw.ElapsedMicroseconds);
     87//                              }
    8888
    8989                                Interlocked.Decrement (ref currentHandlers);
  • binary-improvements/MapRendering/Web/WebConnection.cs

    r326 r332  
    11using System;
    22using System.Collections.Generic;
     3using System.Net;
    34using UnityEngine;
    45
     
    1011                private readonly string conDescription;
    1112
    12                 public WebConnection (string _sessionId, string _endpoint, ulong _steamId) {
     13                public WebConnection (string _sessionId, IPAddress _endpoint, ulong _steamId) {
    1314                        SessionID = _sessionId;
    1415                        Endpoint = _endpoint;
     
    2122                public string SessionID { get; private set; }
    2223
    23                 public string Endpoint { get; private set; }
     24                public IPAddress Endpoint { get; private set; }
    2425
    2526                public ulong SteamID { get; private set; }
     
    3031
    3132                public static bool CanViewAllPlayers (int _permissionLevel) {
    32                         const int defaultPermissionLevel = 0;
    33 
    34                         bool val = _permissionLevel <= defaultPermissionLevel;
    35 
    36                         foreach (WebPermissions.WebModulePermission wap in WebPermissions.Instance.GetModules ()) {
    37                                 if (wap.module.EqualsCaseInsensitive ("webapi.viewallplayers")) {
    38                                         val = _permissionLevel <= wap.permissionLevel;
    39                                 }
    40                         }
    41 
    42                         return val;
     33                        return WebPermissions.Instance.ModuleAllowedWithLevel ("webapi.viewallplayers", _permissionLevel);
    4334                }
    4435
    4536                public static bool CanViewAllClaims (int _permissionLevel) {
    46                         const int defaultPermissionLevel = 0;
    47 
    48                         bool val = _permissionLevel <= defaultPermissionLevel;
    49 
    50                         foreach (WebPermissions.WebModulePermission wap in WebPermissions.Instance.GetModules ()) {
    51                                 if (wap.module.EqualsCaseInsensitive ("webapi.viewallclaims")) {
    52                                         val = _permissionLevel <= wap.permissionLevel;
    53                                 }
    54                         }
    55 
    56                         return val;
     37                        return WebPermissions.Instance.ModuleAllowedWithLevel ("webapi.viewallclaims", _permissionLevel);
    5738                }
    5839
  • binary-improvements/MapRendering/Web/WebPermissions.cs

    r326 r332  
    11using System.Collections.Generic;
     2using System.Collections.ObjectModel;
    23using System.IO;
    34using System.Xml;
     5using UniLinq;
    46
    57namespace AllocsFixes.NetConnections.Servers.Web {
     
    1012
    1113                private readonly Dictionary<string, WebModulePermission> knownModules =
    12                         new Dictionary<string, WebModulePermission> ();
     14                        new CaseInsensitiveStringDictionary<WebModulePermission> ();
    1315
    1416                private readonly Dictionary<string, AdminToken> admintokens = new CaseInsensitiveStringDictionary<AdminToken> ();
     
    1820
    1921                public WebPermissions () {
     22                        allModulesList = new List<WebModulePermission> ();
     23                        allModulesListRO = new ReadOnlyCollection<WebModulePermission> (allModulesList);
    2024                        Directory.CreateDirectory (GetFilePath ());
    2125                        InitFileWatcher ();
     
    5458                        }
    5559
     60                        if (knownModules.TryGetValue (_module, out result)) {
     61                                return result;
     62                        }
     63
    5664                        return defaultModulePermission;
    5765                }
     
    93101                        WebModulePermission p = new WebModulePermission (_module, _permissionLevel);
    94102                        lock (this) {
     103                                allModulesList.Clear ();
    95104                                modules [_module] = p;
    96105                                if (_save) {
     
    104113                                return;
    105114                        }
    106 
    107                         lock (this) {
    108                                 if (!IsKnownModule (_module)) {
    109                                         knownModules.Add (_module, new WebModulePermission (_module, _defaultPermission));
    110                                 }
    111 
    112                                 if (_defaultPermission > 0 && !modules.ContainsKey (_module)) {
    113                                         AddModulePermission (_module, _defaultPermission);
    114                                 }
     115                       
     116                        WebModulePermission p = new WebModulePermission (_module, _defaultPermission);
     117
     118                        lock (this) {
     119                                allModulesList.Clear ();
     120                                knownModules [_module] = p;
    115121                        }
    116122                }
     
    129135                public void RemoveModulePermission (string _module, bool _save = true) {
    130136                        lock (this) {
     137                                allModulesList.Clear ();
    131138                                modules.Remove (_module);
    132139                                if (_save) {
     
    136143                }
    137144
    138                 public List<WebModulePermission> GetModules () {
    139                         List<WebModulePermission> result = new List<WebModulePermission> ();
    140                         foreach (string module in knownModules.Keys) {
    141                                 if (modules.ContainsKey (module)) {
    142                                         result.Add (modules [module]);
    143                                 } else {
    144                                         result.Add (knownModules [module]);
    145                                 }
    146                         }
    147 
    148                         return result;
     145                private readonly List<WebModulePermission> allModulesList;
     146                private readonly ReadOnlyCollection<WebModulePermission> allModulesListRO;
     147
     148                public IList<WebModulePermission> GetModules () {
     149                        if (allModulesList.Count == 0) {
     150                                foreach (KeyValuePair<string, WebModulePermission> kvp in knownModules) {
     151                                        if (modules.ContainsKey (kvp.Key)) {
     152                                                allModulesList.Add (modules [kvp.Key]);
     153                                        } else {
     154                                                allModulesList.Add (kvp.Value);
     155                                        }
     156                                }
     157                        }
     158
     159                        return allModulesListRO;
    149160                }
    150161
     
    302313                                sw.WriteLine (
    303314                                        "               <!-- <token name=\"adminuser1\" token=\"supersecrettoken\" permission_level=\"0\" /> -->");
    304                                 foreach (AdminToken at in admintokens.Values) {
    305                                         sw.WriteLine ("         <token name=\"{0}\" token=\"{1}\" permission_level=\"{2}\" />", at.name, at.token,
    306                                                 at.permissionLevel);
     315                                foreach (KeyValuePair<string, AdminToken> kvp in admintokens) {
     316                                        sw.WriteLine ("         <token name=\"{0}\" token=\"{1}\" permission_level=\"{2}\" />", kvp.Value.name,
     317                                                kvp.Value.token, kvp.Value.permissionLevel);
    307318                                }
    308319
     
    310321                                sw.WriteLine ();
    311322                                sw.WriteLine (" <permissions>");
    312                                 foreach (WebModulePermission wap in modules.Values) {
    313                                         sw.WriteLine ("         <permission module=\"{0}\" permission_level=\"{1}\" />", wap.module,
    314                                                 wap.permissionLevel);
     323                                foreach (KeyValuePair<string, WebModulePermission> kvp in modules) {
     324                                        sw.WriteLine ("         <permission module=\"{0}\" permission_level=\"{1}\" />", kvp.Value.module,
     325                                                kvp.Value.permissionLevel);
    315326                                }
    316327
Note: See TracChangeset for help on using the changeset viewer.