public void TransactionModule_ProcessSyncWithExecutor_NoServersToSendData()
{
var s1 = new TestServerDescription(1);
var s2 = new TestServerDescription(2);
var net = new NetModuleTest(new Dictionary <ServerId, bool> {
{ s1, false }, { s2, true }
});
var trm = new TransactionModule(new QueueConfiguration(1, 1000), net, new TransactionConfiguration(1),
new DistributorHashConfiguration(2));
trm.Start();
var ev = new InnerData(new Transaction("", ""))
{
Transaction = { Destination = new List <ServerId> {
s1, s2
} }
};
using (var trans = trm.Rent())
{
trm.ProcessSyncWithExecutor(ev, trans.Element);
}
Assert.IsTrue(ev.Transaction.IsError);
trm.Dispose();
}
private RemoteResult CreateInner(InnerData obj, bool local)
{
var timer = WriterCounters.Instance.CreateTimer.StartNew();
object key;
object value;
DeserializeData(obj, out key, out value);
var command = _userCommandCreator.Create((TKey)key, (TValue)value);
RemoteResult ret = _implModule.ExecuteNonQuery(command);
if (!ret.IsError)
{
var metaTimer = WriterCounters.Instance.CreateMetaDataTimer.StartNew();
var metaCommand = _metaDataCommandCreator.CreateMetaData(local);
metaCommand = _metaDataCommandCreator.SetKeytoCommand(metaCommand, key);
ret = _implModule.ExecuteNonQuery(metaCommand);
metaTimer.Complete();
}
if (ret.IsError)
{
ret = new InnerServerError(ret);
}
timer.Complete();
return(ret);
}
public InnerData Read(InnerData data)
{
var ret = _db.ReadExternal(data);
WriterCounters.Instance.ReadPerSec.OperationFinished();
return(ret);
}
private RemoteResult UpdateInner(InnerData obj, bool local)
{
object key;
object value;
DeserializeData(obj, out key, out value);
var command = _userCommandCreator.Update((TKey)key, (TValue)value);
RemoteResult ret = _implModule.ExecuteNonQuery(command);
if (!ret.IsError)
{
command = _metaDataCommandCreator.UpdateMetaData(local);
command = _metaDataCommandCreator.SetKeytoCommand(command, key);
ret = _implModule.ExecuteNonQuery(command);
}
if (ret.IsError)
{
ret = new InnerServerError(ret);
}
return(ret);
}
public List <WriterDescription> GetDestination(InnerData ev)
{
_lock.EnterReadLock();
var ret = new List <WriterDescription>();
if (_servers.Count(x => x.IsAvailable) >= _configuration.CountReplics)
{
string current = ev.Transaction.EventHash;
for (int i = 0; i < _configuration.CountReplics; i++)
{
var find =
_map.AvailableMap.FirstOrDefault(
x => HashComparer.Compare(current, x.End) <= 0 && !ret.Contains(x.ServerId));
if (find == null && _map.AvailableMap.Count > 0)
{
current = Consts.StartHashInRing;
find =
_map.AvailableMap.FirstOrDefault(
x => HashComparer.Compare(current, x.End) <= 0 && !ret.Contains(x.ServerId));
}
if (find == null)
{
Logger.Logger.Instance.Error(Errors.NotEnoughServers);
ret.Clear();
break;
}
current = find.End;
ret.Add(find.ServerId);
}
}
_lock.ExitReadLock();
return(ret);
}
internal void Add(TEntity item, DateTime?moment, bool fireEvents)
{
if (item is null)
{
return;
}
LazyLoad();
LazySet();
if (EagerLoadLogic != null)
{
EagerLoadLogic.Invoke(item);
}
if (fireEvents)
{
if (ParentProperty?.RaiseOnChange((OGMImpl)Parent, default(TEntity), item, moment, OperationEnum.Add) ?? false)
{
return;
}
}
CollectionItem <TEntity> oldItem = InnerData.FirstOrDefault(item => item.Item.GetKey() == item.Item.GetKey());
ExecuteAction(AddAction(item, (oldItem != null) ? oldItem.StartDate : moment));
}
public RemoteResult ProcessSync(ServerId server, InnerData data)
{
Logger.Logger.Instance.Debug(string.Format("WriterNetModule: process server = {0}, ev = {1}", server,
data.Transaction.EventHash));
var connection = FindServer(server) as SingleConnectionToWriter;
if (connection == null)
{
ConnectToWriter(server);
connection = FindServer(server) as SingleConnectionToWriter;
}
if (connection == null)
{
Logger.Logger.Instance.Debug(string.Format(
"WriterNetModule: process server not found server = {0}, ev = {1}", server,
data.Transaction.EventHash), "restore");
return(new ServerNotFoundResult());
}
var ret = connection.ProcessSync(data);
if (ret is FailNetResult)
{
RemoveConnection(server);
}
return(ret);
}
public RemoteResult Process(ServerId server, InnerData ev)
{
var connection = FindServer(server) as SingleConnectionToDistributor;
if (connection == null)
{
ConnectToDistributor(server);
connection = FindServer(server) as SingleConnectionToDistributor;
}
if (connection == null)
{
_distributor.ServerNotAvailable(server);
return(new ServerNotFoundResult());
}
var ret = connection.ProcessData(ev);
if (ret is FailNetResult)
{
_distributor.ServerNotAvailable(server);
RemoveConnection(server);
}
return(ret);
}
public RemoteResult Process(ServerId server, InnerData data)
{
Logger.Logger.Instance.Debug(string.Format("DistributorNetModule: process server = {0}, data = {1}", server,
data.Transaction.EventHash));
var connection = FindServer(server) as SingleConnectionToWriter;
if (connection == null)
{
ConnectToWriter(server);
connection = FindServer(server) as SingleConnectionToWriter;
}
if (connection == null)
{
Logger.Logger.Instance.Debug(string.Format(
"DistributorNetModule: process server not found server = {0}, data = {1}", server,
data.Transaction.EventHash));
_distributor.ServerNotAvailable(server);
return(new ServerNotFoundResult());
}
var ret = connection.ProcessData(data);
if (ret is FailNetResult)
{
Logger.Logger.Instance.Debug(string.Format("DistributorNetModule: process fail result server = {0}, data = {1}",
server,
data.Transaction.EventHash));
RemoveConnection(server);
_distributor.ServerNotAvailable(server);
}
return(ret);
}
public InnerData ReadOperation(ServerId server, InnerData data)
{
Logger.Logger.Instance.Debug(string.Format("DistributorNetModule: process server = {0}, data = {1}", server,
data.Transaction.EventHash));
var connection = FindServer(server) as SingleConnectionToWriter;
if (connection == null)
{
ConnectToWriter(server);
connection = FindServer(server) as SingleConnectionToWriter;
}
if (connection == null)
{
Logger.Logger.Instance.Debug(string.Format(
"DistributorNetModule: process server not found server = {0}, data = {1}", server,
data.Transaction.EventHash));
RemoveConnection(server);
_distributor.ServerNotAvailable(server);
return(null);
}
RemoteResult res = null;
var ret = connection.ReadOperation(data, out res);
if (res is FailNetResult)
{
RemoveConnection(server);
_distributor.ServerNotAvailable(server);
}
return(ret);
}
private void ProcessInner(InnerData ev)
{
if (!_mainLogic.Process(ev))
{
_queue.ProxyInputOtherQueue.Add(ev);
}
}
void Initialize(DataRow dr)
{
InnerData.Add("TypeName", dr["TypeName"]); // string
innerData.Add("ProviderDbType", dr["ProviderDbType"]); //int
innerData.Add("ColumnSize", dr["ColumnSize"]); //int
innerData.Add("CreateFormat", dr["CreateFormat"]); //string
innerData.Add("CreateParameters", dr["CreateParameters"]); //string
innerData.Add("DataType", dr["DataType"]); // type? STRING
innerData.Add("IsAutoincrementable", dr["IsAutoincrementable"]); // boolean
innerData.Add("IsBestMatch", dr["IsBestMatch"]); // boolean
innerData.Add("IsCaseSensitive", dr["IsCaseSensitive"]); // boolean
innerData.Add("IsFixedLength", dr["IsFixedLength"]); // boolean
innerData.Add("IsFixedPrecisionScale", dr["IsFixedPrecisionScale"]); // boolean
innerData.Add("IsLong", dr["IsLong"]); // boolean
innerData.Add("IsNullable", dr["IsNullable"]); // boolean
innerData.Add("IsSearchable", dr["IsSearchable"]); // boolean
innerData.Add("IsSearchableWithLike", dr["IsSearchableWithLike"]); // boolean
innerData.Add("IsUnsigned", dr["IsUnsigned"]); // boolean
innerData.Add("MaximumScale", dr["MaximumScale"]); // int
innerData.Add("MinimumScale", dr["MinimumScale"]); // int
innerData.Add("IsConcurrencyType", dr["IsConcurrencyType"]); // boolean
innerData.Add("IsLiteralsSupported", dr["IsLiteralsSupported"]); // boolean
innerData.Add("LiteralPrefix", dr["LiteralPrefix"]); // unknown
innerData.Add("LiteralSuffix", dr["LiteralSuffix"]); // unknown
innerData.Add("NativeDataType", dr["NativeDataType"]); // unknown
}
public InnerData ReadSimple(InnerData data)
{
InnerData result = null;
if (data.Transaction.Destination.Count == 1)
{
result = _net.ReadOperation(data.Transaction.Destination.First(), data);
}
else
{
var retList = new List <InnerData>();
var list = data.Transaction.Destination.Select((server, i) => _tasks[i].ContinueWith((e) =>
{
var ret = _net.ReadOperation(server, data);
if (ret != null)
{
lock (_lock)
{
retList.Add(ret);
}
}
}));
Task.WaitAll(list.ToArray());
result = GetData(retList);
}
return(result);
}
public void DistributorTimeoutCache_GetUpdate()
{
var cache = new DistributorTimeoutCache(TimeSpan.FromMilliseconds(200), TimeSpan.FromMilliseconds(500));
var ev = new InnerData(new Transaction("123", ""))
{
Transaction = { Destination = new List <ServerId>() }
};
cache.AddToCache("123", ev.Transaction);
var ret = cache.Get("123");
Assert.AreEqual(ev.Transaction, ret);
ev.Transaction.Complete();
cache.Update("123", ev.Transaction);
ret = cache.Get("123");
Assert.AreEqual(ev.Transaction, ret);
Thread.Sleep(200);
ret = cache.Get("123");
Assert.AreEqual(ev.Transaction, ret);
Assert.AreEqual(TransactionState.Complete, ev.Transaction.State);
Thread.Sleep(500);
ret = cache.Get("123");
Assert.AreEqual(null, ret);
}
internal void AddRange(IEnumerable <TEntity> items, DateTime?moment, bool fireEvents)
{
LazyLoad();
LazySet();
LinkedList <RelationshipAction> actions = new LinkedList <RelationshipAction>();
foreach (var item in items)
{
if (item is null)
{
continue;
}
if (EagerLoadLogic != null)
{
EagerLoadLogic.Invoke(item);
}
if (fireEvents)
{
if (ParentProperty?.RaiseOnChange((OGMImpl)Parent, default(TEntity), item, moment, OperationEnum.Add) ?? false)
{
continue;
}
}
CollectionItem <TEntity> oldItem = InnerData.FirstOrDefault(item => item.Item.GetKey() == item.Item.GetKey());
actions.AddLast(AddAction(item, (oldItem != null) ? oldItem.StartDate : moment));
}
ExecuteAction(actions);
}
public async Task DiscordBot([Remainder, Name("봇")] string name)
{
using WebClient wc = new WebClient();
EmbedBuilder emb;
string str = "";
try
{
str = wc.DownloadString($"https://koreanbots.dev/api/v2/search/bots?query={name}");
}
catch
{
emb = Context.CreateEmbed(title: "검색 실패", description: "해당 봇을 찾을 수 없어요");
await Context.MsgReplyEmbedAsync(emb.Build());
return;
}
KoreanBotsResult response = JsonConvert.DeserializeObject <KoreanBotsResult>(str);
InnerData b = response.data.data.First();
emb = Context.CreateEmbed(title: b.name, url: $"https://koreanbots.dev/bots/{b.id}", thumbnailUrl: $"https://koreanbots.dev/api/image/discord/avatars/{b.id}.gif?size=512");
emb.AddField("상태", b.status switch
{
"online" => "<:online:708147696879272027>",
"idle" => "<:idle:708147696807968842>",
"dnd" => "<:dnd:708147696976003092>",
"offline" => "<:offline:708147696523018255>",
_ => ":question:"
}, true);
public override RemoteResult RestoreUpdate(InnerData obj, bool local)
{
//TODO тут переделать как придём к решению о различных копиях
var ret = Update(obj, local);
return(ret);
}
private void ProcessData(InnerData data)
{
_lock.EnterReadLock();
bool exit = _isStart;
_lock.ExitReadLock();
if (!exit)
{
return;
}
data.Transaction.OperationName = OperationName.RestoreUpdate;
data.Transaction.OperationType = OperationType.Async;
var result = WriterNet.ProcessSync(_remote, data);
if (result is FailNetResult)
{
Logger.Logger.Instance.InfoFormat("Servers {0} unavailable in recover process", _remote);
_asyncTaskModule.DeleteTask(AsyncTasksNames.RestoreLocal);
_reader.Stop();
_lock.EnterWriteLock();
_isStart = false;
_lock.ExitWriteLock();
}
else if (!_local.Equals(_remote))
{
_db.Delete(data);
}
}
public List <WriterDescription> GetDestination(InnerData data, bool needAllServers)
{
Logger.Logger.Instance.Trace(
string.Format("Distributor: Get destination event hash = {0}, distr hash = {1}",
data.Transaction.EventHash, data.Transaction.DistributorHash));
data.Transaction.IsNeedAllServes = needAllServers;
List <WriterDescription> ret = null;
if (!needAllServers)
{
ret = _modelOfDbWriters.GetDestination(data);
}
else
{
ret = _modelOfDbWriters.GetAllAvailableServers();
}
if (ret.Count == 0)
{
return(null);
}
return(ret);
}
public void Cache_AddGet()
{
var cache = new TestCache(TimeSpan.FromMilliseconds(100));
var ev = new InnerData(new Transaction("123", ""))
{
Transaction = { Destination = new List <ServerId>() }
};
cache.AddToCache("123", ev);
var ret = cache.Get("123");
Assert.AreEqual(ev, ret);
Thread.Sleep(200);
ret = cache.Get("123");
Assert.AreEqual(null, ret);
cache.AddToCache("123", ev);
ret = cache.Get("123");
Assert.AreEqual(ev, ret);
cache.AddToCache("1234", ev);
ret = cache.Get("1234");
Assert.AreEqual(ev, ret);
Thread.Sleep(200);
ret = cache.Get("1234");
Assert.AreEqual(null, ret);
}
public RemoteResult ProcessSync(InnerData data)
{
return(SendFunc <RemoteResult, ICommonNetReceiverWriterForWrite>(
api => api.ProcessSync(data),
e => new ServerNotAvailable(Server),
NetLogHelper.GetLog(data)));
}
private List <InnerData> ReadMetaDataUsingSelect(TCommand script, int countElements, bool isfirstAsk,
ref object lastId,
Func <MetaData, bool> isMine, ref bool isAllDataRead)
{
var list = new List <InnerData>();
var idDescription = PrepareKeyDescription(countElements, isfirstAsk, lastId);
SelectSearchResult result;
int count = 0;
var select = new SelectDescriptionForGeneric <TCommand>(idDescription, script, countElements,
new List <FieldDescription>());
var ret = SelectRead(select, out result);
while (!ret.IsError)
{
bool exit = false;
foreach (var searchData in result.Data)
{
var meta = _metaDataCommandCreator.ReadMetaFromSearchData(searchData);
var data = _userCommandCreator.ReadObjectFromSearchData(searchData.Fields);
meta.Hash = _hashCalculater.CalculateHashFromValue(data);
if (isMine(meta))
{
var innerData = new InnerData(new Transaction(meta.Hash, ""))
{
Data = _hashCalculater.SerializeValue(data),
MetaData = meta
};
list.Add(innerData);
count++;
}
lastId = meta.Id;
if (count == countElements)
{
exit = true;
break;
}
}
if (result.IsAllDataRead || exit)
{
break;
}
idDescription = PrepareKeyDescription(countElements, false, lastId);
select = new SelectDescriptionForGeneric <TCommand>(idDescription, script, count,
new List <FieldDescription>());
ret = SelectRead(select, out result);
}
isAllDataRead = result.IsAllDataRead;
return(list);
}
public void Writer_ProcessDataFromDistributor_SendResultBack()
{
const int distrServer1 = 22180;
const int distrServer12 = 23180;
const int storageServer1 = 22181;
var writer =
new HashWriter(new HashMapConfiguration("TestTransaction1D1S", HashMapCreationMode.CreateNew, 1, 1,
HashFileType.Distributor));
writer.CreateMap();
writer.SetServer(0, "localhost", storageServer1, 157);
writer.Save();
_distributor1.Build(1, distrServer1, distrServer12, "TestTransaction1D1S");
_writer1.Build(storageServer1, "TestTransaction1D1S", 1);
_distributor1.Start();
_writer1.Start();
var list = new List <InnerData>();
const int count = 100;
for (int i = 1; i < count + 1; i++)
{
var ev =
new InnerData(new Transaction(HashConvertor.GetString(i.ToString(CultureInfo.InvariantCulture)), "")
{
OperationName = OperationName.Create,
OperationType = OperationType.Async
})
{
Data = CommonDataSerializer.Serialize(i),
Key = CommonDataSerializer.Serialize(i),
Transaction = { TableName = "Int" }
};
list.Add(ev);
}
foreach (var data in list)
{
_distributor1.Input.ProcessAsync(data);
}
Thread.Sleep(TimeSpan.FromMilliseconds(1000));
foreach (var data in list)
{
var transaction = _distributor1.Main.GetTransactionState(data.Transaction.UserTransaction);
Assert.AreEqual(TransactionState.Complete, transaction.State);
}
var mem = _writer1.Db.GetDbModules.First() as TestDbInMemory;
Assert.AreEqual(count, mem.Local);
_writer1.Dispose();
_distributor1.Dispose();
}
private void ReadSimple(InnerData data, TransactionExecutor executor)
{
var result = executor.ReadSimple(data);
ProcessReadResult(data, result, data.Transaction.ProxyServerId);
data.Transaction.PerfTimer.Complete();
PerfCounters.DistributorCounters.Instance.ProcessPerSec.OperationFinished();
}
public static void Add(string label, InnerData amount)
{
if (amount.value != 0f)
{
Add(label, amount.value);
touched = true;
}
}
private void ExecuteTransaction(InnerData data, TransactionExecutor executor)
{
Logger.Logger.Instance.Debug(string.Format("Transaction process data = {0}", data.Transaction.EventHash));
data.Transaction.StartTransaction();
executor.Commit(data);
}
public void TransactionModule_ProcessSyncWithExecutor_RollbackNoEnoughServers()
{
var server1 = new ServerId("localhost", 21141);
var server2 = new ServerId("localhost", 21142);
var server3 = new ServerId("localhost", 21143);
var netconfig = new ConnectionConfiguration("testService", 10);
var queueconfig = new QueueConfiguration(1, 100);
var distrconfig = new DistributorHashConfiguration(2);
var distributor = new DistributorModule(new AsyncTasksConfiguration(TimeSpan.FromMinutes(5)),
new AsyncTasksConfiguration(TimeSpan.FromMinutes(5)), distrconfig,
queueconfig, null, new ServerId("localhost", 1),
new ServerId("localhost", 1),
new HashMapConfiguration("test10", HashMapCreationMode.CreateNew, 1, 1, HashFileType.Distributor));
var net = new DistributorNetModule(netconfig,
new ConnectionTimeoutConfiguration(Consts.OpenTimeout, Consts.SendTimeout));
net.SetDistributor(distributor);
distributor.Start();
net.Start();
GlobalQueue.Queue.Start();
var s1 = TestHelper.OpenWriterHost(server1, netconfig);
var s2 = TestHelper.OpenWriterHost(server2, netconfig);
net.ConnectToWriter(server1);
net.ConnectToWriter(server2);
Thread.Sleep(TimeSpan.FromMilliseconds(1000));
var ev = new InnerData(new Transaction("", ""))
{
Transaction = { Destination = new List <ServerId> {
server1, server2, server3
} }
};
var trm = new TransactionModule(new QueueConfiguration(1, 1000), net, new TransactionConfiguration(1),
new DistributorHashConfiguration(3));
trm.Start();
using (var trans = trm.Rent())
{
trm.ProcessSyncWithExecutor(ev, trans.Element);
}
Thread.Sleep(TimeSpan.FromMilliseconds(100));
Assert.IsTrue(s1.Value <= 0);
Assert.IsTrue(s2.Value <= 0);
Assert.IsTrue(ev.Transaction.IsError);
net.Dispose();
trm.Dispose();
}
public void ProxyMainLogic_Process_SendDataToRealDistributor()
{
var queue = new QueueConfiguration(1, 1000);
var server1 = new ServerId("localhost", 21171);
var server2 = new ServerId("localhost", 21172);
var server3 = new ServerId("localhost", 21173);
var netconfig = new ConnectionConfiguration("testService", 10);
TestHelper.OpenDistributorHost(server1, netconfig);
TestHelper.OpenDistributorHost(server2, netconfig);
var net = new ProxyNetModule(netconfig,
new ConnectionTimeoutConfiguration(Consts.OpenTimeout, Consts.SendTimeout));
var distributor = new ProxyDistributorModule(new AsyncProxyCache(TimeSpan.FromMinutes(100)), net, queue, server1,
new AsyncTasksConfiguration(TimeSpan.FromDays(1)),
new AsyncTasksConfiguration(TimeSpan.FromDays(1)));
net.SetDistributor(distributor);
var cache = new ProxyCache(TimeSpan.FromSeconds(20));
var main = new ProxyMainLogicModule(distributor, net, cache);
net.Start();
distributor.Start();
distributor.SayIAmHere(server1);
distributor.SayIAmHere(server2);
distributor.SayIAmHere(server3);
cache.Start();
main.Start();
const string hash = "";
var ev = new InnerData(new Transaction("", ""));
ev.Transaction = distributor.CreateTransaction(hash);
ev.Transaction = distributor.CreateTransaction(hash);
ev.Transaction = distributor.CreateTransaction(hash);
ev.Transaction.Destination = new List <ServerId> {
server1
};
bool res = main.Process(ev);
var server = cache.Get(ev.Transaction.EventHash);
Assert.IsNull(server);
Assert.IsTrue(res);
main.Dispose();
distributor.Dispose();
net.Dispose();
}
public IActionResult Index()
{
InnerData ind = new InnerData
{
Name = "dima",
Surname = "Sap"
};
return(View(ind));
}
protected override TEntity?GetItem(DateTime?moment)
{
LazyLoad();
if (!moment.HasValue)
{
moment = RunningTransaction.TransactionDate;
}
return(InnerData.Where(item => item.Overlaps(moment.Value)).Select(item => item.Item).FirstOrDefault());
}
public void Do()
{
List<InnerData> list = new List<InnerData>();
InnerData data1 = new InnerData();
data1.Size = 10;
list.Add(data1);
Console.WriteLine("the inner data outside the list is {0}", data1.Size);
list[0].Size = 20;
Console.WriteLine("after the assgiment in the list then the data1 is {0}", data1.Size);
Console.ReadLine();
}
public void LoadFile(string fileName)
{
if (innerData != null)
{
return;
}
try
{
innerData = InnerData.Read(fileName);
this.sceneNumber = 0;
this.backColor = new Color(innerData.bg[0] / 255.0f, innerData.bg[1] / 255.0f, innerData.bg[2] / 255.0f);
this.mixColor = new Color(innerData.red[0] / 255.0f, innerData.red[1] / 255.0f, innerData.red[2] / 255.0f);
this.moveColor = new Color(innerData.blue[0] / 255.0f, innerData.blue[1] / 255.0f, innerData.blue[2] / 255.0f);
this.userScore = 0;
this.userHits = innerData.showTimes;
//this.userMisses = innerData.missChange;
this.userTime = 0;
this.objectScale = innerData.koef / 100.0f;
this.scoreAddition = innerData.balls;
this.accuracyBonus = innerData.bonusAcc / 100;
this.sizeBonus = innerData.bonusSize / 100;
this.dynamicsBonus = innerData.bonusDin / 100;
this.horizontalTreshold = innerData.horDev / 100.0f;
this.verticalTreshold = innerData.vertDev / 100.0f;
}
catch (Exception e)
{
Debug.Log(e.Message);
return;
}
}
public void UpdateFromMap(IReadOnlyPackage p, IReadOnlyPackage parent, MapClassification classification, string[] mapCompatibility, MapGridType gridType)
{
Dictionary<string, MiniYaml> yaml;
using (var yamlStream = p.GetStream("map.yaml"))
{
if (yamlStream == null)
throw new FileNotFoundException("Required file map.yaml not present in this map");
yaml = new MiniYaml(null, MiniYaml.FromStream(yamlStream, "map.yaml")).ToDictionary();
}
Package = p;
parentPackage = parent;
var newData = innerData.Clone();
newData.GridType = gridType;
newData.Class = classification;
MiniYaml temp;
if (yaml.TryGetValue("MapFormat", out temp))
{
var format = FieldLoader.GetValue<int>("MapFormat", temp.Value);
if (format != Map.SupportedMapFormat)
throw new InvalidDataException("Map format {0} is not supported.".F(format));
}
if (yaml.TryGetValue("Title", out temp))
newData.Title = temp.Value;
if (yaml.TryGetValue("Categories", out temp))
newData.Categories = FieldLoader.GetValue<string[]>("Categories", temp.Value);
if (yaml.TryGetValue("Tileset", out temp))
newData.TileSet = temp.Value;
if (yaml.TryGetValue("Author", out temp))
newData.Author = temp.Value;
if (yaml.TryGetValue("Bounds", out temp))
newData.Bounds = FieldLoader.GetValue<Rectangle>("Bounds", temp.Value);
if (yaml.TryGetValue("Visibility", out temp))
newData.Visibility = FieldLoader.GetValue<MapVisibility>("Visibility", temp.Value);
string requiresMod = string.Empty;
if (yaml.TryGetValue("RequiresMod", out temp))
requiresMod = temp.Value;
newData.Status = mapCompatibility == null || mapCompatibility.Contains(requiresMod) ?
MapStatus.Available : MapStatus.Unavailable;
try
{
// Actor definitions may change if the map format changes
MiniYaml actorDefinitions;
if (yaml.TryGetValue("Actors", out actorDefinitions))
{
var spawns = new List<CPos>();
foreach (var kv in actorDefinitions.Nodes.Where(d => d.Value.Value == "mpspawn"))
{
var s = new ActorReference(kv.Value.Value, kv.Value.ToDictionary());
spawns.Add(s.InitDict.Get<LocationInit>().Value(null));
}
newData.SpawnPoints = spawns.ToArray();
}
else
newData.SpawnPoints = new CPos[0];
}
catch (Exception)
{
newData.SpawnPoints = new CPos[0];
newData.Status = MapStatus.Unavailable;
}
try
{
// Player definitions may change if the map format changes
MiniYaml playerDefinitions;
if (yaml.TryGetValue("Players", out playerDefinitions))
{
newData.Players = new MapPlayers(playerDefinitions.Nodes);
newData.PlayerCount = newData.Players.Players.Count(x => x.Value.Playable);
}
}
catch (Exception)
{
newData.Status = MapStatus.Unavailable;
}
newData.SetRulesetGenerator(modData, () =>
{
var ruleDefinitions = LoadRuleSection(yaml, "Rules");
var weaponDefinitions = LoadRuleSection(yaml, "Weapons");
var voiceDefinitions = LoadRuleSection(yaml, "Voices");
var musicDefinitions = LoadRuleSection(yaml, "Music");
var notificationDefinitions = LoadRuleSection(yaml, "Notifications");
var sequenceDefinitions = LoadRuleSection(yaml, "Sequences");
var rules = Ruleset.Load(modData, this, TileSet, ruleDefinitions, weaponDefinitions,
voiceDefinitions, notificationDefinitions, musicDefinitions, sequenceDefinitions);
var flagged = Ruleset.DefinesUnsafeCustomRules(modData, this, ruleDefinitions,
weaponDefinitions, voiceDefinitions, notificationDefinitions, sequenceDefinitions);
return Pair.New(rules, flagged);
});
if (p.Contains("map.png"))
using (var dataStream = p.GetStream("map.png"))
newData.Preview = new Bitmap(dataStream);
// Assign the new data atomically
innerData = newData;
}
public void UpdateRemoteSearch(MapStatus status, MiniYaml yaml, Action<MapPreview> parseMetadata = null)
{
var newData = innerData.Clone();
newData.Status = status;
newData.Class = MapClassification.Remote;
if (status == MapStatus.DownloadAvailable)
{
try
{
var r = FieldLoader.Load<RemoteMapData>(yaml);
// Map download has been disabled server side
if (!r.downloading)
{
newData.Status = MapStatus.Unavailable;
return;
}
newData.Title = r.title;
newData.Categories = r.categories;
newData.Author = r.author;
newData.PlayerCount = r.players;
newData.Bounds = r.bounds;
newData.TileSet = r.tileset;
var spawns = new CPos[r.spawnpoints.Length / 2];
for (var j = 0; j < r.spawnpoints.Length; j += 2)
spawns[j / 2] = new CPos(r.spawnpoints[j], r.spawnpoints[j + 1]);
newData.SpawnPoints = spawns;
newData.GridType = r.map_grid_type;
try
{
newData.Preview = new Bitmap(new MemoryStream(Convert.FromBase64String(r.minimap)));
}
catch (Exception e)
{
Log.Write("debug", "Failed parsing mapserver minimap response: {0}", e);
newData.Preview = null;
}
var playersString = Encoding.UTF8.GetString(Convert.FromBase64String(r.players_block));
newData.Players = new MapPlayers(MiniYaml.FromString(playersString));
newData.SetRulesetGenerator(modData, () =>
{
var rulesString = Encoding.UTF8.GetString(Convert.FromBase64String(r.rules));
var rulesYaml = new MiniYaml("", MiniYaml.FromString(rulesString)).ToDictionary();
var ruleDefinitions = LoadRuleSection(rulesYaml, "Rules");
var weaponDefinitions = LoadRuleSection(rulesYaml, "Weapons");
var voiceDefinitions = LoadRuleSection(rulesYaml, "Voices");
var musicDefinitions = LoadRuleSection(rulesYaml, "Music");
var notificationDefinitions = LoadRuleSection(rulesYaml, "Notifications");
var sequenceDefinitions = LoadRuleSection(rulesYaml, "Sequences");
var rules = Ruleset.Load(modData, this, TileSet, ruleDefinitions, weaponDefinitions,
voiceDefinitions, notificationDefinitions, musicDefinitions, sequenceDefinitions);
var flagged = Ruleset.DefinesUnsafeCustomRules(modData, this, ruleDefinitions,
weaponDefinitions, voiceDefinitions, notificationDefinitions, sequenceDefinitions);
return Pair.New(rules, flagged);
});
}
catch (Exception e)
{
Log.Write("debug", "Failed parsing mapserver response: {0}", e);
}
// Commit updated data before running the callbacks
innerData = newData;
if (innerData.Preview != null)
cache.CacheMinimap(this);
if (parseMetadata != null)
parseMetadata(this);
}
// Update the status and class unconditionally
innerData = newData;
}
public MapPreview(ModData modData, string uid, MapGridType gridType, MapCache cache)
{
this.cache = cache;
this.modData = modData;
Uid = uid;
innerData = new InnerData
{
Title = "Unknown Map",
Categories = new[] { "Unknown" },
Author = "Unknown Author",
TileSet = "unknown",
Players = null,
PlayerCount = 0,
SpawnPoints = NoSpawns,
GridType = gridType,
Bounds = Rectangle.Empty,
Preview = null,
Status = MapStatus.Unavailable,
Class = MapClassification.Unknown,
Visibility = MapVisibility.Lobby,
};
}
