public void EventFactory_GetDoorEventJson()
{
SecurityEvent door = EventMonitor.Events.EventFactory.GetByJSON("{\"Type\":\"Door\", \"Date\":\"2014-02-01 10:01:02\", \"open\": true}");
Assert.IsTrue(door is SecurityEvent);
Assert.IsTrue(door is Door);
}
public void EventFactory_GetAlarmEventJson()
{
SecurityEvent alarm = EventMonitor.Events.EventFactory.GetByJSON("{\"Type\":\"alarm\", \"Date\":\"2014-02-01 10:01:05\", \"name\":\"fire\", \"floor\":\"1\", \"room\":\"101\"}");
Assert.IsTrue(alarm is SecurityEvent);
Assert.IsTrue(alarm is Alarm);
}
public void EventFactory_GetImageEventJson()
{
SecurityEvent image = EventMonitor.Events.EventFactory.GetByJSON("{\"Type\":\"img\", \"Date\":\"2014-02-01 10:01:02\", \"bytes\": \"ab39szh6\", \"size\": 8}");
Assert.IsTrue(image is SecurityEvent);
Assert.IsTrue(image is Image);
}
/// <summary>
/// Performs the actual logging of a security event
/// </summary>
/// <param name="projectName">The name of the project.</param>
/// <param name="userName">The name of the user.</param>
/// <param name="eventType">The type of event.</param>
/// <param name="eventRight">The right of the event.</param>
/// <param name="message">Any security message.</param>
protected override void DoLogEvent(string projectName, string userName, SecurityEvent eventType, SecurityRight eventRight, string message)
{
// Generate the log entry
XmlDocument auditXml = new XmlDocument();
XmlElement xmlRoot = auditXml.CreateElement("event");
auditXml.AppendChild(xmlRoot);
AddXmlElement(auditXml, xmlRoot, "dateTime", DateTime.Now.ToString("o", CultureInfo.CurrentCulture));
if (!string.IsNullOrEmpty(projectName))
{
AddXmlElement(auditXml, xmlRoot, "project", projectName);
}
if (!string.IsNullOrEmpty(userName))
{
AddXmlElement(auditXml, xmlRoot, "user", userName);
}
AddXmlElement(auditXml, xmlRoot, "type", eventType.ToString());
if (eventRight != SecurityRight.Inherit)
{
AddXmlElement(auditXml, xmlRoot, "outcome", eventRight.ToString());
}
if (!string.IsNullOrEmpty(message))
{
AddXmlElement(auditXml, xmlRoot, "message", message);
}
// Write the entry
string auditLog = executionEnvironment.EnsurePathIsRooted(this.auditFile);
lock (this)
{
File.AppendAllText(auditLog, auditXml.OuterXml.Replace(Environment.NewLine, " ") + Environment.NewLine);
}
}
public void Notify(SecurityEvent securityEvent)
{
_observers.AsParallel().WithMergeOptions(ParallelMergeOptions.NotBuffered).ForAll(eventSubscriber =>
{
eventSubscriber.Update(securityEvent);
});
}
public override void Update(SecurityEvent securityEvent)
{
Communication.LoggingService.Instance().LogSecurityEvent(new List <SecurityEvent>()
{
securityEvent
});
}
public void GetSecurities()
{
List <Security> securities = new List <Security>();// TryToLoadSecurities();
/* if (securities != null)
* {
* SecurityEvent?.Invoke(securities);
* SendLogMessage("Securities downloaded. Count: " + securities.Count, LogMessageType.System);
* return;
* }*/
SendLogMessage("Securities downloading...", LogMessageType.System);
List <string> engines = GetEngines();
List <string> markets = GetMarkets(engines);
List <string> classes = GetClasses(markets);
securities = GetSecurities(classes);
securities = CreateFuturesSection(securities);
SecurityEvent?.Invoke(securities);
SendLogMessage("Securities downloaded. Count: " + securities.Count, LogMessageType.System);
//SaveSecurities(securities);
}
private List <SecurityEvent> MapSecEvents(IEnumerable <AuditProxy> audits)
{
var list = new List <SecurityEvent>();
foreach (var item in audits)
{
var secEvent = new SecurityEvent();
string found = null;
ActionFieldsLibrary.ActionMapper.TryGetValue(item.Action, out found);
var action = found ?? item.Action.ToString();
secEvent.DeviceTime = item.InDateTime;
secEvent.EventName = EventPrefix + action;
secEvent.EventDescription = item.Comment;
secEvent.EventCategory = item.ObjectName;
secEvent.UserName = item.UserBrief == null?item.UserId.ToString() : item.UserBrief;
secEvent.HostIP = _settings.Server;
secEvent.HostName = item.HostInfoName;
secEvent.ExtraParams.Add("EventID", item.AuditId.ToString());
secEvent.ExtraParams.Add("ObjectID", item.ObjectId.ToString());
list.Add(secEvent);
}
return(list);
}
private void button1_Click(object sender, EventArgs e)
{
Task.Factory.StartNew(() =>
{
Random random = new Random();
List <SecurityEvent> list = new List <SecurityEvent>();
for (int i = 0; i < 100000; i++)
{
var securityEvent = new SecurityEvent()
{
PhysicalLocation = "Some Where " + i,
DetectorId = i,
EventDescription = "Help " + i,
DetectorType = (EnumsDedectorType)random.Next(0, 1),
};
list.Add(securityEvent);
// Task task = new Task(() => EventProducer.Instance().LogSecurityEvent(securityEvent));
// task.Start();
}
list.AsParallel().ForAll(se => EventProducer.Instance().LogSecurityEvent(se));
});
}
/// <summary>
/// получены инструменты с сервера
/// </summary>
/// <param name="products"></param>
private void ClientReceivedSecurities(RootProducts products)
{
List <Security> securities = new List <Security>();
foreach (var product in products.Data)
{
var newSec = new Security();
newSec.Name = product.Symbol;
newSec.NameClass = product.QuoteAsset;
newSec.NameFull = product.Symbol;
newSec.NameId = product.Symbol;
newSec.Decimals = product.TickSize.DecimalsCount();
newSec.SecurityType = SecurityType.CurrencyPair;
newSec.State = product.Status == "Normal" ? SecurityStateType.Activ : SecurityStateType.Close;
newSec.Lot = 1;
newSec.PriceStep = product.TickSize.ToDecimal();
newSec.PriceStepCost = newSec.PriceStep;
newSec.Go = product.MinNotional.ToDecimal();
securities.Add(newSec);
}
SecurityEvent?.Invoke(securities);
}
private T GetValue()
{
if (hashBuffer != GetChecksum())
{
SecurityEvent.CallMemoryHacked();
OnHackedInstance.TryInvoke();
}
return(value);
}
/// <summary>
/// Sends a security event to the audit loggers.
/// </summary>
/// <param name="projectName">The name of the project.</param>
/// <param name="userName">The name of the user.</param>
/// <param name="eventType">The type of event.</param>
/// <param name="eventRight">The right of the event.</param>
/// <param name="message">Any security message.</param>
public virtual void LogEvent(string projectName, string userName, SecurityEvent eventType, SecurityRight eventRight, string message)
{
if (loggers != null)
{
foreach (IAuditLogger logger in loggers)
{
logger.LogEvent(projectName, userName, eventType, eventRight, message);
}
}
}
private void _btn_fire_Click(object sender, EventArgs e)
{
var securityEvent = new SecurityEvent()
{
PhysicalLocation = "Upper Floor",
DetectorId = 1,
EventDescription = "Fire Fire !!!!",
DetectorType = EnumsDedectorType.Fire
};
EventProducer.Instance().LogSecurityEvent(securityEvent);
}
public void LogSecurityEvent(SecurityEvent securityEvent)
{
try
{
using (var client = new LoggingServiceClient())
{
client.LogSecurityEvent(securityEvent);
}
}
catch (Exception)
{
}
}
/// <summary>
/// пришел список инструментов биржи
/// </summary>
private void ClientOnUpdatedSecurities(List <Instrument> securities)
{
if (_securities == null)
{
_securities = new List <Security>();
}
for (int sec = 0; sec < securities.Count; sec++)
{
var lmaxSec = securities[sec];
if (_securities.Find(s => s.Name == lmaxSec.Name.Replace("/", "-")) != null)
{
_securities.Add(
new Security
{
Name = lmaxSec.Name.Replace("/", "-") + "_2",
NameId = lmaxSec.Id.ToString(),
NameClass = lmaxSec.Contract.Currency,
Lot = lmaxSec.OrderBook.QuantityIncrement,
PriceStep = lmaxSec.OrderBook.PriceIncrement,
PriceStepCost = lmaxSec.OrderBook.PriceIncrement,
});
if (lmaxSec.OrderBook.PriceIncrement < 1)
{
_securities.Last().Decimals =
lmaxSec.OrderBook.PriceIncrement.ToString(CultureInfo.InvariantCulture).Split('.')[1].Length;
}
continue;
}
_securities.Add(
new Security
{
Name = lmaxSec.Name.Replace("/", "-"),
NameId = lmaxSec.Id.ToString(),
NameClass = lmaxSec.Contract.Currency,
Lot = lmaxSec.OrderBook.QuantityIncrement,
PriceStep = lmaxSec.OrderBook.PriceIncrement,
PriceStepCost = lmaxSec.OrderBook.PriceIncrement
});
if (lmaxSec.OrderBook.PriceIncrement < 1)
{
_securities.Last().Decimals =
lmaxSec.OrderBook.PriceIncrement.ToString(CultureInfo.InvariantCulture).Split('.')[1].Length;
}
}
SecurityEvent?.Invoke(_securities);
}
/// <summary>
/// Brokerages can send portfolio updates which should include average price of holdings and the
/// quantity of holdings, we'll trust this information as truth and just set the portfolio with it
/// </summary>
private void HandleSecurityHoldingUpdated(SecurityEvent holding)
{
// how close are we?
var securityHolding = _algorithm.Portfolio[holding.Symbol];
var deltaQuantity = securityHolding.Quantity - holding.Quantity;
var deltaAvgPrice = securityHolding.AveragePrice - holding.AveragePrice;
if (deltaQuantity != 0 || deltaAvgPrice != 0)
{
Log.Trace(string.Format("BrokerageTransactionHandler.HandleSecurityHoldingUpdated(): {0} DeltaQuantity: {1} DeltaAvgPrice: {2}", holding.Symbol, deltaQuantity, deltaAvgPrice));
}
securityHolding.SetHoldings(holding.AveragePrice, holding.Quantity);
}
public void EventFactory_GetMalformedEventJson()
{
SecurityEvent malformed = null;
try
{
malformed = EventMonitor.Events.EventFactory.GetByJSON("malformed");
}
catch
{
// Can't find a good way to test for thrown exception.
Assert.IsNull(malformed);
}
}
/// <summary>
/// Logs a security event.
/// </summary>
/// <param name="projectName">The name of the project.</param>
/// <param name="userName">The name of the user.</param>
/// <param name="eventType">The type of event.</param>
/// <param name="eventRight">The right of the event.</param>
/// <param name="message">Any security message.</param>
public virtual void LogEvent(string projectName, string userName, SecurityEvent eventType, SecurityRight eventRight, string message)
{
if ((eventRight == SecurityRight.Allow) && this.logSuccessfulEvents)
{
DoLogEvent(projectName, userName, eventType, eventRight, message);
}
else if ((eventRight == SecurityRight.Deny) && this.logFailureEvents)
{
DoLogEvent(projectName, userName, eventType, eventRight, message);
}
else if (eventRight == SecurityRight.Inherit)
{
DoLogEvent(projectName, userName, eventType, eventRight, message);
}
}
/// <summary>
/// Logs a security event.
/// </summary>
/// <param name="projectName">The name of the project.</param>
/// <param name="userName">The name of the user.</param>
/// <param name="eventType">The type of event.</param>
/// <param name="eventRight">The right of the event.</param>
/// <param name="message">Any security message.</param>
public virtual void LogEvent(string projectName, string userName, SecurityEvent eventType, SecurityRight eventRight, string message)
{
if ((eventRight == SecurityRight.Allow) && this.logSuccessfulEvents)
{
DoLogEvent(projectName, userName, eventType, eventRight, message);
}
else if ((eventRight == SecurityRight.Deny) && this.logFailureEvents)
{
DoLogEvent(projectName, userName, eventType, eventRight, message);
}
else if (eventRight == SecurityRight.Inherit)
{
DoLogEvent(projectName, userName, eventType, eventRight, message);
}
}
/// <summary>
/// Brokerages can send portfolio updates which should include average price of holdings and the
/// quantity of holdings, we'll trust this information as truth and just set the portfolio with it
/// </summary>
private void HandleSecurityHoldingUpdated(SecurityEvent holding)
{
// how close are we?
var securityHolding = _algorithm.Portfolio[new Symbol(holding.Symbol)];
var deltaQuantity = securityHolding.Quantity - holding.Quantity;
var deltaAvgPrice = securityHolding.AveragePrice - holding.AveragePrice;
if (deltaQuantity != 0 || deltaAvgPrice != 0)
{
Log.Trace(string.Format("BrokerageTransactionHandler.HandleSecurityHoldingUpdated(): {0} DeltaQuantity: {1} DeltaAvgPrice: {2}", holding.Symbol, deltaQuantity, deltaAvgPrice));
}
// we don't actually want to do this, this data can be delayed
//securityHolding.SetHoldings(holding.AveragePrice, holding.Quantity);
}
public void Notify(SecurityEvent securityEvent)
{
switch (securityEvent.DetectorType)
{
case Enums.DedectorType.Fire:
_notifiers[Enums.SubscriberType.Fire].Notify(securityEvent);
break;
case Enums.DedectorType.Security:
_notifiers[Enums.SubscriberType.Security].Notify(securityEvent);
break;
default:
Console.WriteLine("Not defined yet");
break;
}
}
/// <summary>
/// Event invocator for the PortfolioChanged event
/// </summary>
/// <param name="e">The PortfolioEvent</param>
protected virtual void OnPortfolioChanged(SecurityEvent e)
{
try
{
Log.Trace("Brokerage.OnPortfolioChanged(): " + e);
var handler = SecurityHoldingUpdated;
if (handler != null)
{
handler(this, e);
}
}
catch (Exception error)
{
Log.Error("Brokerage.OnPortfolioChanged(): Caught Error: " + error.Message);
}
}
/// <summary>
/// Given a file path will wait until the file is free, open the file, grab the contents,
/// and create a SecurityEvent.
/// </summary>
/// <param name="path">Path to the file that contains the JSON for the SecurityEvent.</param>
/// <returns>True if successful, false otherwise.</returns>
public static bool Process(string path)
{
FileStream stream = null;
byte[] buffer = null;
try
{
if (File.Exists(path))
{
while (true)
{
try
{
stream = System.IO.File.Open(path, FileMode.Open, FileAccess.Read, FileShare.Read);
buffer = new byte[stream.Length];
stream.Read(buffer, 0, buffer.Length);
break;
}
catch (IOException)
{
System.Diagnostics.Debug.WriteLine("File is locked. Waiting 5ms. File: " + path);
System.Threading.Thread.Sleep(5);
}
finally
{
if (stream != null)
{
stream.Close();
}
}
}
SecurityEvent myEvent = EventMonitor.Events.EventFactory.GetByJSON(Encoding.ASCII.GetString(buffer));
return(true);
}
}
catch (Exception ex)
{
Console.WriteLine(string.Format("Could not read file {0}. Message: {1}", path, ex.Message));
}
return(false);
}
public static SecurityEvent ToSecurityEvent(RuleEvenPlus rep)
{
SecurityEvent se = new SecurityEvent();
se.Description = rep.Desc;
se.EventGuid = rep.Guid;
se.Name = rep.Name;
if (rep.Actions != null && rep.Actions.Count > 0)
{
foreach (RuleActionPlus rap in rep.Actions)
{
se.SecurityActions.Add(ToSecurityAction(rap));
}
}
return(se);
}
public void LogEventSendsEventToLogger()
{
string projectName = "Test Project";
string userName = "******";
SecurityEvent eventType = SecurityEvent.ForceBuild;
SecurityRight eventRight = SecurityRight.Allow;
string message = "A message";
IAuditLogger logger = mocks.Create <IAuditLogger>(MockBehavior.Strict).Object;
Mock.Get(logger).Setup(_logger => _logger.LogEvent(projectName, userName, eventType, eventRight, message)).Verifiable();
manager.AuditLoggers = new IAuditLogger[] {
logger
};
manager.Initialise();
manager.LogEvent(projectName, userName, eventType, eventRight, message);
}
public void LogEventSendsEventToLogger()
{
string projectName = "Test Project";
string userName = "******";
SecurityEvent eventType = SecurityEvent.ForceBuild;
SecurityRight eventRight = SecurityRight.Allow;
string message = "A message";
IAuditLogger logger = mocks.CreateMock <IAuditLogger>();
Expect.Call(delegate { logger.LogEvent(projectName, userName, eventType, eventRight, message); });
mocks.ReplayAll();
manager.AuditLoggers = new IAuditLogger[] {
logger
};
manager.Initialise();
manager.LogEvent(projectName, userName, eventType, eventRight, message);
}
public static RuleEvenPlus FromSecurityEvent(SecurityEvent se)
{
RuleEvenPlus rep = new RuleEvenPlus();
rep.Desc = se.Description;
rep.Guid = se.EventGuid;
rep.Name = se.Name;
if (se.SecurityActions.Count > 0)
{
rep.Actions = new List <RuleActionPlus>();
foreach (SecurityAction sa in se.SecurityActions)
{
rep.Actions.Add(FromSecurityAction(sa));
}
}
return(rep);
}
/// <summary>
/// Performs the actual logging of a security event
/// </summary>
/// <param name="projectName">The name of the project.</param>
/// <param name="userName">The name of the user.</param>
/// <param name="eventType">The type of event.</param>
/// <param name="eventRight">The right of the event.</param>
/// <param name="message">Any security message.</param>
protected override void DoLogEvent(string projectName, string userName, SecurityEvent eventType, SecurityRight eventRight, string message)
{
// Generate the log entry
XmlDocument auditXml = new XmlDocument();
XmlElement xmlRoot = auditXml.CreateElement("event");
auditXml.AppendChild(xmlRoot);
AddXmlElement(auditXml, xmlRoot, "dateTime", DateTime.Now.ToString("o", CultureInfo.CurrentCulture));
if (!string.IsNullOrEmpty(projectName)) AddXmlElement(auditXml, xmlRoot, "project", projectName);
if (!string.IsNullOrEmpty(userName)) AddXmlElement(auditXml, xmlRoot, "user", userName);
AddXmlElement(auditXml, xmlRoot, "type", eventType.ToString());
if (eventRight != SecurityRight.Inherit) AddXmlElement(auditXml, xmlRoot, "outcome", eventRight.ToString());
if (!string.IsNullOrEmpty(message)) AddXmlElement(auditXml, xmlRoot, "message", message);
// Write the entry
string auditLog = executionEnvironment.EnsurePathIsRooted(this.auditFile);
lock (this)
{
File.AppendAllText(auditLog, auditXml.OuterXml.Replace(Environment.NewLine, " ") + Environment.NewLine);
}
}
public RawSecurityDescriptor ShowDialog(IntPtr hWnd, SecurityPageType pageType = SecurityPageType.BasicPermissions, SecurityPageActivation pageAct = SecurityPageActivation.ShowDefault)
{
System.Diagnostics.Debug.WriteLine(string.Format("ShowDialog: {0} {1}", pageType, pageAct));
SecurityEventArg sd = null;
SecurityEvent fn = delegate(SecurityEventArg e) { sd = e; };
try
{
OnSetSecurity += fn;
if (System.Environment.OSVersion.Version.Major == 5 || (pageType == SecurityPageType.BasicPermissions && pageAct == SecurityPageActivation.ShowDefault))
{
if (!NativeMethods.EditSecurity(hWnd, this))
{
Marshal.ThrowExceptionForHR(Marshal.GetHRForLastWin32Error());
}
}
else
{
uint uPage = (uint)pageType & ((uint)pageAct << 16);
NativeMethods.EditSecurityAdvanced(hWnd, this, uPage);
}
if (sd != null)
{
string sddl = NativeMethods.SecurityDescriptorPtrToSDLL(sd.SecurityDesciptor, sd.Parts);
if (!string.IsNullOrEmpty(sddl))
{
System.Diagnostics.Debug.WriteLine(string.Format("ShowDialog: Return: {0}", sddl));
return(new RawSecurityDescriptor(sddl));
}
}
}
finally
{
OnSetSecurity -= fn;
}
System.Diagnostics.Debug.WriteLine(string.Format("ShowDialog: Return: null"));
return(null);
}
internal async Task <ObservableCollection <SecurityEvent> > GetLastEventsFor(string homeId, string personId)
{
ObservableCollection <SecurityEvent> events = new ObservableCollection <SecurityEvent>();
foreach (Home home in Homes)
{
if (home.Id == homeId)
{
NextEvents nextEvents = await _aPICommands.GetLastEventOf(homeId, personId).ConfigureAwait(false);
if (nextEvents != null)
{
foreach (HomeData.Event rawEvent in nextEvents.Body.Events)
{
SecurityEvent newEvent = Home.CreateNewSecurityEvent(rawEvent);
events.Add(newEvent);
}
return(events);
}
}
}
return(events);
}
public void GetSecurities()
{
SendLogMessage("Securities downloading...", LogMessageType.System);
string requestString =
"http://mfd.ru/export/";
string response = GetRequest(requestString);
string[] lines = response.Split('\n');
List <string> classes = GetClasses(lines);
List <Security> securities = new List <Security>();
for (int i = 0; i < classes.Count; i++)
{
securities.AddRange(GetAllSecuritiesToClass(classes[i]));
}
SecurityEvent?.Invoke(securities);
SendLogMessage("Securities downloaded. Count: " + securities.Count, LogMessageType.System);
}
/// <summary>
/// получены инструменты с сервера
/// </summary>
/// <param name="products"></param>
private void ClientReceivedSecurities(List <Product> products)
{
List <Security> securities = new List <Security>();
foreach (var product in products)
{
var newSec = new Security();
newSec.Name = product.baseAsset + "-" + product.quoteAsset;
newSec.NameClass = product.quoteAsset;
newSec.NameFull = product.symbol;
newSec.NameId = product.symbol;
newSec.Decimals = product.priceScale;
newSec.SecurityType = SecurityType.CurrencyPair;
newSec.State = product.status == "Normal" ? SecurityStateType.Activ : SecurityStateType.Close;
newSec.Lot = GetValueByDecimals(product.qtyScale);
newSec.PriceStep = GetValueByDecimals(product.priceScale);
newSec.PriceStepCost = newSec.PriceStep;
securities.Add(newSec);
}
SecurityEvent?.Invoke(securities);
}
/// <summary>
/// Starts a new filter with the event type and inner filter.
/// </summary>
/// <param name="eventType"></param>
/// <param name="innerFilter"></param>
public EventTypeAuditFilter(SecurityEvent eventType, AuditFilterBase innerFilter)
: base(innerFilter)
{
this.type = eventType;
}
/// <summary> /// Performs the actual logging of a security event /// </summary> /// <param name="projectName">The name of the project.</param> /// <param name="userName">The name of the user.</param> /// <param name="eventType">The type of event.</param> /// <param name="eventRight">The right of the event.</param> /// <param name="message">Any security message.</param> protected abstract void DoLogEvent(string projectName, string userName, SecurityEvent eventType, SecurityRight eventRight, string message);
/// <summary>
/// Filters by event type.
/// </summary>
/// <param name="eventType"></param>
/// <returns></returns>
public virtual AuditFilterBase ByEventType(SecurityEvent eventType)
{
return new EventTypeAuditFilter(eventType, this);
}
/// <summary>
/// Filters by event type.
/// </summary>
/// <param name="eventType"></param>
/// <returns></returns>
public static AuditFilterBase ByEventType(SecurityEvent eventType)
{
return new EventTypeAuditFilter(eventType);
}
/// <summary>
/// Checks to see if a session has the required right to perform a permission.
/// </summary>
/// <param name="sessionToken">The session to check.</param>
/// <param name="projectName">The project the permission is for.</param>
/// <param name="permission">The permission being checked.</param>
/// <param name="eventType">The event type for logging.</param>
private void CheckSecurity(string sessionToken,
string projectName,
SecurityPermission permission,
SecurityEvent? eventType)
{
// NASTY HACK: Bypass all security if the session override is being used
if (sessionToken == SecurityOverride.SessionIdentifier)
{
return;
}
// Retrieve the project authorisation
IProjectAuthorisation authorisation = null;
bool requiresSession = securityManager.RequiresSession;
string userName = securityManager.GetUserName(sessionToken);
string displayName = securityManager.GetDisplayName(sessionToken, null) ?? userName;
if (!string.IsNullOrEmpty(projectName))
{
IProjectIntegrator projectIntegrator = GetIntegrator(projectName);
if ((projectIntegrator != null) &&
(projectIntegrator.Project != null) &&
(projectIntegrator.Project.Security != null))
{
// The project has been found and it has security
authorisation = projectIntegrator.Project.Security;
requiresSession = authorisation.RequiresSession(securityManager);
// if "Guest" have some rights, the service must be able to check the
// rights for "Guest", but without userName it wont work.
if (string.IsNullOrEmpty(userName))
userName = authorisation.GuestAccountName;
}
else if ((projectIntegrator != null) &&
(projectIntegrator.Project != null) &&
(projectIntegrator.Project.Security == null))
{
// The project is found, but security is missing - application error
string errorMessage = string.Format(CultureInfo.CurrentCulture, "Security not found for project {0}", projectName);
Log.Error(errorMessage);
if (eventType.HasValue)
{
securityManager.LogEvent(projectName,
userName,
eventType.Value,
SecurityRight.Deny,
errorMessage);
}
throw new SecurityException(errorMessage);
}
else
{
// Couldn't find the requested project
string errorMessage = string.Format(CultureInfo.CurrentCulture, "project not found {0}", projectName);
Log.Error(errorMessage);
if (eventType.HasValue)
{
securityManager.LogEvent(projectName,
userName,
eventType.Value,
SecurityRight.Deny,
errorMessage);
}
throw new NoSuchProjectException(projectName);
}
}
if (!requiresSession || (userName != null))
{
if (string.IsNullOrEmpty(projectName))
{
// Checking server-level security
if (!securityManager.CheckServerPermission(userName, permission))
{
string info = string.Format(CultureInfo.CurrentCulture, "{2} [{0}] has been denied {1} permission at the server",
userName, permission, displayName);
Log.Warning(info);
if (eventType.HasValue)
{
securityManager.LogEvent(projectName,
userName,
eventType.Value,
SecurityRight.Deny,
info);
}
throw new PermissionDeniedException(permission.ToString());
}
else
{
string info = string.Format(CultureInfo.CurrentCulture, "{2} [{0}] has been granted {1} permission at the server",
userName, permission, displayName);
Log.Debug(info);
if (eventType.HasValue)
{
securityManager.LogEvent(projectName,
userName,
eventType.Value,
SecurityRight.Allow,
info);
}
return;
}
}
else
{
// Checking project-level security
if (!authorisation.CheckPermission(securityManager,
userName,
permission,
securityManager.GetDefaultRight(permission)))
{
string info = string.Format(CultureInfo.CurrentCulture, "{3} [{0}] has been denied {1} permission on '{2}'",
userName, permission, projectName, displayName);
Log.Warning(info);
if (eventType.HasValue)
{
securityManager.LogEvent(projectName,
userName,
eventType.Value,
SecurityRight.Deny,
info);
}
throw new PermissionDeniedException(permission.ToString());
}
else
{
Log.Debug(string.Format(CultureInfo.CurrentCulture, "{3} [{0}] has been granted {1} permission on '{2}'",
userName,
permission,
projectName,
displayName));
if (eventType.HasValue)
{
securityManager.LogEvent(projectName,
userName,
eventType.Value,
SecurityRight.Allow,
null);
}
return;
}
}
}
else
{
SecurityRight defaultRight = securityManager.GetDefaultRight(permission);
switch (defaultRight)
{
case SecurityRight.Allow:
Log.Debug(string.Format(CultureInfo.CurrentCulture, "{3} [{0}] has been granted {1} permission on '{2}'",
userName,
permission,
projectName,
displayName));
return;
default:
// Tell the user that the session is unknown
var info = string.Format(CultureInfo.CurrentCulture, "Session with token '{0}' is not valid", sessionToken);
Log.Warning(info);
if (eventType.HasValue)
{
securityManager.LogEvent(projectName,
null,
eventType.Value,
SecurityRight.Deny,
info);
}
throw new SessionInvalidException();
}
}
}
/// <summary>
/// Encapsulates the code to process a request.
/// </summary>
/// <param name="request"></param>
/// <param name="permission"></param>
/// <param name="eventType"></param>
/// <param name="action"></param>
/// <returns></returns>
private Response RunServerRequest(ServerRequest request,
SecurityPermission? permission,
SecurityEvent? eventType,
Action<ServerRequest> action)
{
Response response = new Response(request);
try
{
// Validate the request and check the security token
ValidateRequest(request);
if (permission.HasValue)
{
CheckSecurity(request.SessionToken,
null,
permission.Value,
eventType);
}
// Perform the actual action
action(request);
response.Result = ResponseResult.Success;
}
catch (Exception error)
{
// Security exceptions have already been logged, just need to log any other exception
if (!(error is SecurityException))
{
Log.Warning(error);
}
// Tell the caller the request failed and include the error message (but not the stack trace!)
response.Result = ResponseResult.Failure;
response.ErrorMessages.Add(
new ErrorMessage(
error.Message,
error.GetType().Name));
}
return response;
}
/// <summary>
/// Encapsulates the code to process a request.
/// </summary>
/// <param name="request"></param>
/// <param name="permission"></param>
/// <param name="eventType"></param>
/// <param name="action"></param>
/// <returns></returns>
private Response RunProjectRequest(ProjectRequest request,
SecurityPermission? permission,
SecurityEvent? eventType,
ProjectRequestAction action)
{
var response = new Response(request);
try
{
// Validate the request and check the security token
ValidateRequest(request);
if (permission.HasValue)
{
CheckSecurity(request.SessionToken,
request.ProjectName,
permission.Value,
eventType);
}
// Perform the actual action
action(request, response);
if (response.Result == ResponseResult.Unknown)
{
response.Result = ResponseResult.Success;
}
}
catch (Exception error)
{
// Log any errors to help diagnosing issues
Log.Warning(error);
response.Result = ResponseResult.Failure;
response.ErrorMessages.Add(
new ErrorMessage(
error.Message,
error.GetType().Name));
}
return response;
}
/// <summary>
/// Starts a new filter with the event type.
/// </summary>
/// <param name="eventType"></param>
public EventTypeAuditFilter(SecurityEvent eventType)
: this(eventType, null) { }
/// <summary>
/// Checks to see if a session has the required right to perform a permission.
/// </summary>
/// <param name="sessionToken">The session to check.</param>
/// <param name="projectName">The project the permission is for.</param>
/// <param name="permission">The permission being checked.</param>
/// <param name="eventType">The event type for logging.</param>
/// <returns>The display name of the user if the permission is allowed.</returns>
private string CheckSecurity(string sessionToken,
string projectName,
SecurityPermission permission,
SecurityEvent? eventType)
{
// Retrieve the project authorisation
IProjectAuthorisation authorisation = null;
bool requiresSession = securityManager.RequiresSession;
string userName = securityManager.GetUserName(sessionToken);
string displayName = securityManager.GetDisplayName(sessionToken, null) ?? userName;
if (!string.IsNullOrEmpty(projectName))
{
IProjectIntegrator projectIntegrator = GetIntegrator(projectName);
if ((projectIntegrator != null) &&
(projectIntegrator.Project != null) &&
(projectIntegrator.Project.Security != null))
{
// The project has been found and it has security
authorisation = projectIntegrator.Project.Security;
requiresSession = authorisation.RequiresSession(securityManager);
}
else if ((projectIntegrator != null) &&
(projectIntegrator.Project != null) &&
(projectIntegrator.Project.Security == null))
{
// The project is found, but security is missing - application error
string errorMessage = string.Format("Security not found for project {0}", projectName);
Log.Error(errorMessage);
if (eventType.HasValue)
{
securityManager.LogEvent(projectName,
userName,
eventType.Value,
SecurityRight.Deny,
errorMessage);
}
throw new SecurityException(errorMessage);
}
else
{
// Couldn't find the requested project
string errorMessage = string.Format("project not found {0}", projectName);
Log.Error(errorMessage);
if (eventType.HasValue)
{
securityManager.LogEvent(projectName,
userName,
eventType.Value,
SecurityRight.Deny,
errorMessage);
}
throw new NoSuchProjectException(projectName);
}
}
if (!requiresSession || (userName != null))
{
if (string.IsNullOrEmpty(projectName))
{
// Checking server-level security
if (!securityManager.CheckServerPermission(userName, permission))
{
string info = string.Format("{2} [{0}] has been denied {1} permission at the server",
userName, permission, displayName);
Log.Warning(info);
if (eventType.HasValue)
{
securityManager.LogEvent(projectName,
userName,
eventType.Value,
SecurityRight.Deny,
info);
}
throw new PermissionDeniedException(permission.ToString());
}
else
{
string info = string.Format("{2} [{0}] has been granted {1} permission at the server",
userName, permission, displayName);
Log.Debug(info);
if (eventType.HasValue)
{
securityManager.LogEvent(projectName,
userName,
eventType.Value,
SecurityRight.Allow,
info);
}
return displayName;
}
}
else
{
// Checking project-level security
if (!authorisation.CheckPermission(securityManager,
userName,
permission,
securityManager.GetDefaultRight(permission)))
{
string info = string.Format("{3} [{0}] has been denied {1} permission on '{2}'",
userName, permission, projectName, displayName);
Log.Warning(info);
if (eventType.HasValue)
{
securityManager.LogEvent(projectName,
userName,
eventType.Value,
SecurityRight.Deny,
info);
}
throw new PermissionDeniedException(permission.ToString());
}
else
{
Log.Debug(string.Format("{3} [{0}] has been granted {1} permission on '{2}'",
userName,
permission,
projectName,
displayName));
if (eventType.HasValue)
{
securityManager.LogEvent(projectName,
userName,
eventType.Value,
SecurityRight.Allow,
null);
}
return displayName;
}
}
}
else
{
SecurityRight defaultRight = securityManager.GetDefaultRight(permission);
switch (defaultRight)
{
case SecurityRight.Allow:
Log.Debug(string.Format("{3} [{0}] has been granted {1} permission on '{2}'",
userName,
permission,
projectName,
displayName));
return string.Empty;
default:
// Tell the user that the session is unknown
var info = string.Format("Session with token '{0}' is not valid", sessionToken);
Log.Warning(info);
if (eventType.HasValue)
{
securityManager.LogEvent(projectName,
null,
eventType.Value,
SecurityRight.Deny,
info);
}
throw new SessionInvalidException();
}
}
}
