/// <summary>
/// Add URL to the listing record
/// </summary>
/// <param name="url"></param>
public void AddFileListingTest(string url)
{
if (!ListingFilesTest.Contains(url))
{
ListingFilesTest.Add(url);
}
}
public ThreadSafeList <DomainsItem> GetResolutionDomains(string ip)
{
ip = ip.Trim().ToLower();
var lstDominios = new ThreadSafeList <string>(relations.Items.Where(W => W.Ip.Ip.ToLower() == ip.ToLower()).Select(S => S.Domain.Domain));
return(new ThreadSafeList <DomainsItem>(domains.Items.Where(D => lstDominios.Contains(D.Domain))));
}
public void CreateRoomInternal(IClientCallback client, int requestId, Room room, bool detectOwner = true)
{
if (string.IsNullOrEmpty(room.Name))
{
answers.InQueue(
new ChatAnswer(client, AnswerCode.RequestStatusReceived,
new List <object> {
new Answer(requestId, ChatResultCode.Error)
}), lockTimeout);
return;
}
bool timeoutFlag;
if (rooms.Contains(room, lockTimeout, out timeoutFlag))
{
answers.InQueue(
new ChatAnswer(client, AnswerCode.RequestStatusReceived,
new List <object> {
new Answer(requestId, ChatResultCode.RoomExists)
}), lockTimeout);
return;
}
// устанавливаем владельца
var user = users.Find(u => u.ClientCallback == client, lockTimeout);
if (user == null)
{
answers.InQueue(
new ChatAnswer(client, AnswerCode.RequestStatusReceived,
new List <object> {
new Answer(requestId, ChatResultCode.UnknownUser)
}), lockTimeout);
return;
}
// администратор может устанавливать любого владельца
// а ткаже выставлять флаг сохранения комнаты даже в случае неактивности
if (((int)user.RoleMask & (int)UserRole.Administrator) == 0)
{
room.Owner = user.ID;
room.IsBound = false;
}
// указанный владелец не существует
if (users.Find(u => u.ID == room.Owner, lockTimeout) == null)
{
room.Owner = user.ID;
}
answers.InQueue(
new ChatAnswer(client, AnswerCode.RequestStatusReceived,
new List <object> {
new Answer(requestId, ChatResultCode.Ok)
}), lockTimeout);
CreateRoomInternal(room);
}
public ThreadSafeList <IPsItem> GetResolutionIPs(string domain)
{
domain = domain.Trim().ToLower();
var lstIPs = new ThreadSafeList <string>(relations.Items.Where(W => W.Domain.Domain.ToLower() == domain.ToLower()).Select(S => S.Ip.Ip));
return(new ThreadSafeList <IPsItem>(Ips.Items.Where(I => lstIPs.Contains(I.Ip))));
}
/// <summary>
/// Extract existing folders from a given list of URLs
/// </summary>
/// <param name="lsturls"></param>
/// <returns></returns>
private static ThreadSafeList <string> _ExtractFoldersRuntime(IEnumerable <string> lsturls)
{
var folders = new ThreadSafeList <string>();
var foldersBackups = new ThreadSafeList <string>();
foreach (var url in lsturls)
{
var u = new Uri(url);
if (u.ToString().EndsWith("//"))
{
var auxSingleUrl = new ThreadSafeList <string> {
u.ToString().Remove(u.ToString().Length - 1, 1)
};
return(_ExtractFoldersRuntime(auxSingleUrl));
}
var offSetProtocol = url.IndexOf("://", StringComparison.Ordinal);
var protocol = url.Substring(0, offSetProtocol);
var foldersSplit = u.AbsolutePath.Split('/');
var path = string.Empty;
for (var i = 0; i < foldersSplit.Length; i++)
{
if (i + 1 != foldersSplit.Length)
{
path += foldersSplit[i] + "/";
}
if (folders.Contains(protocol + "://" + u.Host + path) || path.Contains("."))
{
continue;
}
folders.Add(protocol + "://" + u.Host + path);
// ToDo use a list provided by the user
string[] compressExt = { ".zip", ".rar", ".tar", ".gz", ".tar.gz" };
var path1 = path;
foreach (
var extension in
compressExt.Where(
extension =>
protocol + "://" + u.Host + path1.Substring(0, path1.Length - 1) !=
protocol + "://" + u.Host)
.Where(
extension =>
!foldersBackups.Contains(protocol + "://" + u.Host +
path1.Substring(0, path1.Length - 1) +
extension)))
{
foldersBackups.Add(protocol + "://" + u.Host + path.Substring(0, path.Length - 1) +
extension);
}
}
}
return(foldersBackups);
}
public bool ContainsConnector(bool isInput, ConnectorObject connector)
{
if (isInput)
{
return(inputConveyors.Contains(connector));
}
else
{
return(outputConveyors.Contains(connector));
}
}
/// <summary>
/// Remove this transaction from the send queue.
///
/// In case this is an interrupted transaction, generate and queue the rest.
/// </summary>
/// <param name="tx"></param>
private void RemoveTransactionToSend(Transaction tx)
{
lock (_transactionsToSendLock)
{
if (_transactionsToSend.Contains(tx))
{
_transactionsToSend.Remove(tx);
if (tx.Interrupted && !tx.Aborted)
{
GenerateTransactionsToSend(tx.Message);
}
}
}
}
public ChatResultCode MoveToRoomWithNoAnswer(int userId, string roomName, string password, int requestId)
{
var user = users.Find(u => u.ID == userId, lockTimeout);
if (user == null)
{
Logger.InfoFormat("[{0}]MoveToRoomWithNoAnswer: user not found, room={1}", requestId, roomName);
return(ChatResultCode.UnknownUser);
}
var room = rooms.Find(r => r.Name == roomName, lockTimeout);
if (room == null)
{
Logger.InfoFormat("[{0}]MoveToRoomWithNoAnswer: room {1} not found, user={2}", requestId, roomName, user);
return(ChatResultCode.UnknownRoom);
}
bool timeoutFlag;
var userAndRoomExists = usersAndRooms.Contains(new Cortege2 <int, int> {
a = userId, b = room.Id
}, lockTimeout, out timeoutFlag);
if (userAndRoomExists)
{
return(ChatResultCode.AlreadyEnteredRoom);
}
// проверяем пароль
if (!string.IsNullOrEmpty(room.Password) && room.Password != password)
{
Logger.InfoFormat("[{0}]MoveToRoomWithNoAnswer: password not correct, user={1}, room={2}", requestId, user, roomName);
return(ChatResultCode.Error);
}
usersAndRooms.Add(new Cortege2 <int, int>(userId, room.Id), lockTimeout);
room.UserCount++;
// сбрасываем время автоматического удаления комнаты
room.ExpireTime = null;
Logger.InfoFormat("[{0}]MoveToRoomWithNoAnswer: user {1} entered room {2}", requestId, user, roomName);
var action = new UserAction
{
UserId = userId,
ActionType = UserActionType.RoomEnter,
Room = roomName,
TimeStamp = DateTime.Now
};
userActions.Add(action, lockTimeout);
SendUserAction(action);
return(ChatResultCode.Ok);
}
/// <summary>
/// Generate possible backup file names
/// </summary>
/// <param name="path"></param>
/// <param name="fileName"></param>
/// <param name="fileExtension"></param>
/// <returns></returns>
private static ThreadSafeList <string> _MutexFileRuntime(string path, string fileName, string fileExtension)
{
var lstFiles = new ThreadSafeList <string>();
// ToDo use a list provided by the user
string[] backupExt = { "old", "bak", "back", "1", "2", "txt", "~", "save", "backup" };
string[] oldVersions = { "1", "2", "_1", "_2", "_backup" };
fileExtension = fileExtension.Trim('.');
foreach (var newFile in (from newExt in backupExt.Concat(oldVersions)
let aux = path.Split(new[] { "/" }, StringSplitOptions.None)
let realPath = string.Join("/", aux.Take(aux.Count() - 1)) + "/"
select(string.Equals(newExt, "~"))
? realPath + fileName + "." + fileExtension + newExt
: realPath + fileName + "." + fileExtension + "." + newExt).Where(
newFile => !lstFiles.Contains(newFile)))
{
lstFiles.Add(newFile);
}
return(lstFiles);
}
public override void Process(RocketPreflightComplete packet, NitroxServer.Player player)
{
Optional <NeptuneRocketModel> opRocket = vehicleManager.GetVehicleModel <NeptuneRocketModel>(packet.Id);
if (opRocket.HasValue)
{
ThreadSafeList <PreflightCheck> list = opRocket.Value.PreflightChecks;
if (!list.Contains(packet.FlightCheck))
{
list.Add(packet.FlightCheck);
}
else
{
Log.Error($"{nameof(RocketPreflightCompleteProcessor)}: Received an existing preflight '{packet.FlightCheck}' for rocket '{packet.Id}'");
}
}
else
{
Log.Error($"{nameof(RocketPreflightCompleteProcessor)}: Can't find server model for rocket with id {packet.Id}");
}
playerManager.SendPacketToOtherPlayers(packet, player);
}
public object CreateInstance(System.Reflection.MethodInfo methodInfo, System.Reflection.ParameterInfo parmeterInfo)
{
lock (lock_flag)
{
ValidatorMethodMapping mapping = new ValidatorMethodMapping(methodInfo);
if (!methodMappingContainer.ContainsKey(methodInfo.DeclaringType))
{
return(null);
}
var mappings = methodMappingContainer[methodInfo.DeclaringType];
var methodMapping = mappings.Where(pre => pre == mapping).FirstOrDefault();
if (methodMapping.MethodParameters != null && methodMapping.MethodParameters.Length > 0)
{
var parameterMapping = methodMapping.MethodParameters.Where(pre => pre.ParameterInfo.ParameterType == parmeterInfo.ParameterType && pre.ParameterInfo.Position == parmeterInfo.Position).FirstOrDefault();
if (parameterMapping == null || parameterMapping.ValidatorType == null)
{
return(null);
}
//如果不包含则处理所有的内容
if (!validatorInstanceTypeContainer.Contains(parameterMapping.ValidatorType))
{
ObjectContainer.RegisterInstance(parameterMapping.ValidatorType, ObjectContainer.CreateInstance(parameterMapping.ValidatorType));
}
return(ObjectContainer.CreateInstance(parameterMapping.ValidatorType));
}
return(null);
}
}
public void LeaveRoom(string room)
{
ChatSettings.Instance.RemoveRoom(room);
try
{
bool timeoutFlag;
if (!enteredRooms.Contains(room, LockTimeout, out timeoutFlag))
{
return;
}
if (!sender.IsOnline)
{
Logger.Error("Внутренняя ошибка (ChatControlBackEnd.LeaveRoom)");
return;
}
sender.LeaveRoom(room);
}
catch (Exception ex)
{
Logger.Error("Ошибка выхода из комнаты чата (ChatControlBackEnd.LeaveRoom)", ex);
}
}
private int[] CalculateBiomes(ChunkCoordinates coordinates, ChunkLandscape landscape)
{
// var biomes = BiomeProvider.GetBiomes().ToArray();
int worldX = coordinates.X << 4;
int worldZ = coordinates.Z << 4;
float[] weightedBiomes = new float[256];
var biomeData = new int[SampleArraySize * SampleArraySize];
for (int x = -SampleSize; x < SampleSize + 5; x++)
{
for (int z = -SampleSize; z < SampleSize + 5; z++)
{
var xx = worldX + ((x * 8f));
var zz = worldZ + ((z * 8f));
var temp = TemperatureNoise.GetValue(xx, zz);
//Note for self: The temperature noise returns a value between -1 & 1 however we need the value to be between 0 & 2.
//We do this by getting the absolute value (0 to 1) and multiplying it by 2.
temp = MathF.Abs(temp) * 2f;
var rain = MathF.Abs(RainfallNoise.GetValue(xx, zz));
if (temp < _lowestTemp)
{
_lowestTemp = temp;
}
if (temp > _highestTemp)
{
_highestTemp = temp;
}
if (rain < _lowestHumidity)
{
_lowestHumidity = rain;
}
if (rain > _highestHumidity)
{
_highestHumidity = rain;
}
_totalTemp += temp;
_totalHumidity += rain;
_totalLookups++;
if (_totalLookups % 1024 == 0)
{
/* Console.Clear();
*
* Console.WriteLine(
* $"Average temperature: {_totalTemp / _totalLookups} Highest: {_highestTemp} Lowest: {_lowestTemp}");
*
* Console.WriteLine(
* $"Average humidity: {_totalHumidity / _totalLookups} Highest: {_highestHumidity} Lowest: {_lowestHumidity}");
*
* Console.WriteLine($"Unique biomes: {_uniqueBiomes.Count}");*/
}
biomeData[(x + SampleSize) * SampleArraySize + (z + SampleSize)] = (BiomeProvider.GetBiome(
(float)temp, (float)rain).Id);
}
}
for (int x = 0; x < 16; x++)
{
for (int z = 0; z < 16; z++)
{
int index = NoiseMap.GetIndex(x, z);
float totalWeight = 0;
for (int mapX = 0; mapX < SampleArraySize; mapX++)
{
for (int mapZ = 0; mapZ < SampleArraySize; mapZ++)
{
float weight = _weightings[mapX * SampleArraySize + mapZ][(x << 4) + z];
if (weight > 0)
{
totalWeight += weight;
weightedBiomes[biomeData[mapX * SampleArraySize + mapZ]] += weight;
}
}
}
// normalize biome weights
for (int biomeIndex = 0; biomeIndex < weightedBiomes.Length; biomeIndex++)
{
weightedBiomes[biomeIndex] /= totalWeight;
}
// combine mesa biomes
// mesaCombiner.adjust(weightedBiomes);
landscape.Noise[index] = 0f;
float river = TerrainBase.GetRiverStrength(new BlockCoordinates(worldX + x, 0, worldZ + z), this);
landscape.River[index] = -river;
float maxWeight = 0f;
for (int i = 0; i < weightedBiomes.Length; i++)
{
var value = weightedBiomes[i];
if (value > 0f)
{
var biome = BiomeProvider.GetBiome(i);
landscape.Noise[index] += biome.RNoise(
this, worldX + x, worldZ + z, value, river + 1f) * value;
weightedBiomes[i] = 0f;
if (value > maxWeight)
{
maxWeight = value;
landscape.Biome[index] = biome;
if (!_uniqueBiomes.Contains(biome.Id))
{
_uniqueBiomes.TryAdd(biome.Id);
// Console.WriteLine($"Unique biomes: {uniqueBiomes.Count}");
}
}
}
}
//landscape.Biome[index] = weightedBiomes.;
// landscape.Biome[index] = BiomeProvider.GetBiome(i);
//landscape.Biome[index] = BiomeProvider.GetBiome();
}
}
return(biomeData);
}
/// <summary>
///
/// </summary>
private void SendEmails(EmailMessage[] messagesArray)
{
countMessagesInAllMail = messagesArray.Sum(ma => ma.Receivers.Length);
Logger.InfoFormat("начинаем отправку {0} сообщений", messagesArray.Length);
using (var client = new SmtpClient())
{
foreach (var message in messagesArray)
{
countMessagesInCurrentMail = message.Receivers.Length;
currentNomberMessagesInCurrentMail = 0;
if (isStopping)
{
break;
}
if (breakCurrentDelivered)
{
break;
}
Logger.InfoFormat("Начинаем рассылку сообщения '{0}' {1} получателям", message.Title, message.Receivers.Length);
if ((int)MinUrgency > (int)message.Urgency)
{
continue; // Если уровень важности сообщения менее важный чем указанный минимальный, то не отсылаем это сообщение
}
foreach (var recv in message.Receivers)
{
using (var msg = new MailMessage {
IsBodyHtml = message.HTMLFormat
})
{
if (isStopping)
{
break;
}
currentNomberMessagesInCurrentMail++;
bool timeOutFlaf;
// Если этот адрес в fail-списке, то не отправляем по нему сообщение
if (failReceiversList.Contains(recv, 1000, out timeOutFlaf) && !sendToAddressInFailList)
{
continue;
}
currentReceiver = recv;
msg.Subject = message.Title;
msg.Body = message.Body;
msg.To.Clear();
MailAddress mailAddress;
try
{
mailAddress = new MailAddress(recv);
}
catch (Exception ex)
{
Logger.Error("new MailAddress(recv)", ex);
continue;
}
msg.To.Add(mailAddress);
var timeStartSend = DateTime.Now;
try
{
client.Send(msg); // Засекаем время и пытаемся отправить сообщение
var milsSpared = (DateTime.Now - timeStartSend).TotalMilliseconds;
Logger.InfoFormat("сообщения '{0}' отправлено получателю {1}. Время отправки {2}",
message.Title, recv, milsSpared);
CheckTimeOut(milsSpared, recv, message);
Interlocked.Increment(ref totalDelivered);
}
#region catch
catch (Exception ex)
{
var milsSpared = (DateTime.Now - timeStartSend).TotalMilliseconds;
Logger.ErrorFormat(
"Сбой доставки сообщения '{0}' получателю {1}. Время отправки составило {2}. " +
"Этот адрес будет занесён в список заблокированных адресов. Ошибка: {3}",
message.Title, recv, milsSpared, ex);
errorList.Add(new DeliveryServerError
{
ReasonMessage =
String.Format("Сбой доставки сообщения '{0}' по причине {1}", message.Title,
ex.Message),
Urgency = message.Urgency,
DateException = DateTime.Now,
ExceptionLink = ex,
TimeSpan = milsSpared,
Receiver = recv
}, 1000);
if (!failReceiversList.AddIfNotContains(recv, 1000))
{
Logger.ErrorFormat(
String.Format("Не удалось добавить адрес {0} в список заблокированных адресов",
recv));
}
else
{
Logger.Info(String.Format("Адрес {0} добавлен в список заблокированных адресов",
recv));
}
}
#endregion
}
}
if (failReceiversList.Count >= message.Receivers.Length)
{
ModuleStatusController.Instance.Status.AddError(ServiceProcessState.HasWarnings,
"Чёрный список больше, чем количество получателей сообщения.", DateTime.Now, ErrorCodeBlackListTooLarge);
}
//else
// ModuleStatusController.Instance.Status.RemoveError(ServiceProcessState.HasWarnings, ErrorCodeBlackListTooLarge);
}
countMessagesInAllMail = 0;
}
}
public bool ContainsConveyor(TransportPipeInfo info)
{
return(conveyors.Contains(info));
}
public bool IsOpen(IDocument document)
{
return(_openDocuments.Contains(document));
}