protected virtual void Application_Start(object sender, EventArgs e, HttpApplication application)
{
var op = DetailedLogger.CreateOperation(); // category: general
DetailedLogger.Log(op, "Application_Start"); // category: general
var runOnceMarkerPath = application.Server.MapPath("/" + RunOnceGuid);
var firstRun = File.Exists(runOnceMarkerPath);
var startConfig = new ContentRepository.RepositoryStartSettings {
StartLuceneManager = !firstRun
};
RepositoryInstance.WaitForWriterLockFileIsReleased(RepositoryInstance.WaitForLockFileType.OnStart);
Repository.Start(startConfig);
//-- <L2Cache>
StorageContext.L2Cache = new L2CacheImpl();
//-- </L2Cache>
GlobalConfiguration.Configure(WebApiConfiguration.Register);
RegisterRoutes(RouteTable.Routes, application);
RepositoryPathProvider.Register();
//preload
WarmUp.Preload();
op.Finish(); // category: general
}
public void CommitPopulateNode(object data, IndexDocumentData indexDocument = null)
{
var state = (DocumentPopulatorData)data;
#if INDEX
DetailedLogger.Log("Populating node. V:{0}, VId:{1}, Path:{2}", state.Node.Version, state.Node.VersionId, state.Node.Path); // category: INDEX
#endif
if (!state.OriginalPath.Equals(state.NewPath, StringComparison.InvariantCultureIgnoreCase))
{
DeleteTree(state.OriginalPath, true);
PopulateTree(state.NewPath);
}
else if (state.IsNewNode)
{
CreateBrandNewNode(state.Node, indexDocument);
}
else if (state.Settings.IsNewVersion())
{
AddNewVersion(state.Node, indexDocument);
}
else
{
UpdateVersion(state, indexDocument);
}
OnNodeIndexed(state.Node.Path);
}
protected virtual void Application_End(object sender, EventArgs e, HttpApplication application)
{
//LuceneManager.ShutDown();
var op = DetailedLogger.CreateOperation(); // category: general
DetailedLogger.Log(op, "Application_End"); // category: general
ContentRepository.Repository.Shutdown();
Logger.WriteInformation(Logger.EventId.NotDefined, "Application_End");
op.Finish(); // category: general
}
public void RefreshIndex(IEnumerable <Node> nodes)
{
foreach (var node in nodes)
{
#if INDEX
DetailedLogger.Log("DocumentPopulator.RefreshIndex. V: {0}, VId: {1}", node.Version, node.VersionId); // category: INDEX
#endif
RefreshIndex(node, false);
}
}
void OnEndRequest(object sender, EventArgs e)
{
var ctx = ((HttpApplication)sender).Context;
var originalPath = ctx.Items["OriginalPath"] as string;
var request = ctx.Request;
if (originalPath != null)
{
ctx.RewritePath(originalPath);
}
#if WEB
DetailedLogger.Log("PCM.OnEndRequest {0} {1}", request.RequestType, request.Url); // category: WEB
#endif
}
/// <summary>
/// Create a new CimToolBase with your mod settings. This will create
/// instances of useful tools and you can access them from this class.
/// </summary>
/// <param name="modSettings">Your mod settings</param>
public CimToolBase(CimToolSettings modSettings)
{
m_modSettings = modSettings;
m_spriteUtilities = new SpriteUtilities();
m_uiUtilities = new UIUtilities();
m_strings = new Strings(this);
m_path = new Path(this);
m_version = new Version(this);
m_detailedLogger = new DetailedLogger(this);
m_namedLogger = new NamedLogger(this);
m_translation = new Translation(this);
m_xmlOptions = new XmlFileManager(this);
m_saveFileOptions = new SaveFileManager(this);
m_changelog = new Changelog(this);
m_modOptions = new ModOptionPanelUtilities(this);
}
private IEnumerable <int> GetIdResults(ExecutionHint hint, int top, int skip, IEnumerable <SortInfo> sort,
FilterStatus enableAutofilters, FilterStatus enableLifespanFilter)
{
if (ContentRepository.User.Current.Id == -1 && !this.IsSafe)
{
var ex = new InvalidOperationException("Cannot execute this query.");
ex.Data.Add("EventId", ContentRepository.EventId.Querying.CannotExecuteQuery);
ex.Data.Add("Query", this._text);
//Diagnostics.Logger.WriteError(ContentRepository.EventId.Error.CannotExecuteQuery, ex);
throw ex;
}
if (IsNodeQuery)
{
#if QUERY
var op = DetailedLogger.CreateOperation(); // category: QUERY
DetailedLogger.Log(op, "NodeQuery {0} | Top:{1} Skip:{2} Sort:{3}", this._text, _settings.Top, _settings.Skip, // category: QUERY
_settings.Sort == null ? "" : String.Join(",", _settings.Sort.Select(s => s.FieldName + (s.Reverse ? " ASC" : " DESC"))));
#endif
var result = GetIdResultsWithNodeQuery(hint, top, skip, sort, enableAutofilters, enableLifespanFilter);
#if QUERY
op.Finish();
#endif
return(result);
}
if (IsContentQuery)
{
#if QUERY
var op = DetailedLogger.CreateOperation(); // category: QUERY
DetailedLogger.Log(op, "ContentQuery {0} | Top:{1} Skip:{2} Sort:{3}", this._text, _settings.Top, _settings.Skip, // category: QUERY
_settings.Sort == null ? "" : String.Join(",", _settings.Sort.Select(s => s.FieldName + (s.Reverse ? " ASC" : " DESC"))));
#endif
var result = GetIdResultsWithLucQuery(top, skip, sort, enableAutofilters, enableLifespanFilter);
#if QUERY
op.Finish();
#endif
return(result);
}
throw new InvalidOperationException("Cannot execute query with null or empty Text");
}
/* ============================================================================== Init */
public ClusterChannel(IClusterMessageFormatter formatter, ClusterMemberInfo clusterMemberInfo)
{
_incomingMessages = new List <ClusterMessage>();
CounterManager.Reset("IncomingMessages");
CounterManager.Reset("TotalMessagesToProcess");
//_incomingMessageSignal = new AutoResetEvent(false);
m_formatter = formatter;
m_clusterMemberInfo = clusterMemberInfo;
// initiate processing threads
for (var i = 0; i < RepositoryConfiguration.MessageProcessorThreadCount; i++)
{
var thstart = new ParameterizedThreadStart(CheckProcessableMessages);
var thread = new Thread(thstart);
//thread.Priority = ThreadPriority.Highest;
thread.Name = i.ToString();
thread.Start();
#if INDEX
DetailedLogger.Log("ClusterChannel: 'CheckProcessableMessages' thread started. ManagedThreadId: {0}", thread.ManagedThreadId); // category: INDEX
#endif
}
}
internal IEnumerable <LucObject> Execute(bool allVersions, IQueryExecutor executor)
{
#if QUERY
var op = DetailedLogger.CreateOperation(); // category: QUERY
DetailedLogger.Log(op, "LucQuery.Execute {0} | CountOnly:{1} Top:{2} Skip:{3} Sort:{4}", this.Query, // category: QUERY
this.CountOnly ? "yes" : "no",
this.Top, this.Skip,
this.HasSort ? String.Join(",", this.SortFields.Select(s => s.GetField() + (s.GetReverse() ? " ASC" : " DESC"))) : "");
#endif
if (this.FieldLevel == QueryFieldLevel.NotDefined)
{
this.FieldLevel = DetermineFieldLevel();
}
var result = executor.Execute(this, allVersions);
TotalCount = executor.TotalCount;
#if QUERY
op.Finish();
#endif
return(result == null ? new LucObject[0] : result);
}
public virtual Document CreateDocument()
{
using (var optrace = new OperationTrace("CreateDocument"))
{
if (_indexDocumentData != null)
{
//Trace.WriteLine("###I> create document from indexdocumentdata");
// create document from indexdocumentdata if it has been supplied (eg via MSMQ if it was small enough to send it over)
var docInfo = _indexDocumentData.IndexDocumentInfo as IndexDocumentInfo;
var doc = IndexDocumentInfo.CreateDocument(docInfo, _indexDocumentData);
optrace.IsSuccessful = true;
#if INDEX
if (doc == null)
{
DetailedLogger.Log("LM: LuceneDocumentActivity.CreateDocument: Document is NULL from QUEUE");
}
#endif
return(doc);
}
else
{
//Trace.WriteLine("###I> get document from db");
// create document via loading it from db (eg when indexdocumentdata was too large to send over MSMQ)
var doc = IndexDocumentInfo.GetDocument(this.VersionId);
optrace.IsSuccessful = true;
#if INDEX
if (doc == null)
{
DetailedLogger.Log("LM: LuceneDocumentActivity.CreateDocument: Document is NULL from DB");
}
#endif
return(doc);
}
}
}
internal void InternalExecute()
{
try
{
#if INDEX
var persistentActivity = this as Search.Indexing.Activities.LuceneIndexingActivity;
var id = persistentActivity == null ? "" : ", ActivityId: " + persistentActivity.ActivityId;
var op = DetailedLogger.CreateOperation();
DetailedLogger.Log(op, "LUCENEACTIVITY: {0} {1}", this.GetType().Name, id); // category: INDEX
#endif
using (new ContentRepository.Storage.Security.SystemAccount())
Execute();
#if INDEX
op.Finish(); // category: INDEX
#endif
}
finally
{
if (FinishSignal != null)
{
FinishSignal.Set();
}
}
}
internal static void Shutdown()
{
if (_instance == null)
{
Logger.WriteWarning(Logger.EventId.NotDefined, "Repository shutdown has already completed.");
return;
}
lock (_shutDownSync)
{
if (_instance == null)
{
Logger.WriteWarning(Logger.EventId.NotDefined, "Repository shutdown has already completed.");
return;
}
DetailedLogger.Log("Sending a goodbye message."); // category: general
_instance.ConsoleWriteLine();
_instance.ConsoleWriteLine("Sending a goodbye message...");
DistributedApplication.ClusterChannel.ClusterMemberInfo.NeedToRecover = false;
var pingMessage = new PingMessage();
pingMessage.Send();
foreach (var svc in _instance.serviceInstances)
{
DetailedLogger.Log("Shutting down {0}", svc.GetType().Name); // category: general
svc.Shutdown();
}
BackgroundOperations.TaskManager.Stop();
DetailedLogger.Log("Shutting down {0}", DistributedApplication.ClusterChannel.GetType().Name); // category: general
DistributedApplication.ClusterChannel.ShutDown();
if (Instance.StartSettings.BackupIndexAtTheEnd)
{
DetailedLogger.Log("Backing up the index."); // category: general
if (LuceneManagerIsRunning)
{
_instance.ConsoleWriteLine("Backing up the index...");
BackupTools.SynchronousBackupIndex();
_instance.ConsoleWriteLine("The backup of index is finished.");
}
else
{
_instance.ConsoleWriteLine("Backing up index is skipped because Lucene was not started.");
}
}
if (LuceneManagerIsRunning)
{
DetailedLogger.Log("Shutting down LuceneManager."); // category: general
LuceneManager.ShutDown();
}
DetailedLogger.Log("Waiting for writer lock file is released."); // category: general
WaitForWriterLockFileIsReleased(WaitForLockFileType.OnEnd);
DetailedLogger.Log("Repository has stopped."); // category: general
var t = DateTime.UtcNow - _instance._startupInfo.Starting;
var msg = String.Format("Repository has stopped. Running time: {0}.{1:d2}:{2:d2}:{3:d2}", t.Days,
t.Hours, t.Minutes, t.Seconds);
_instance.ConsoleWriteLine(msg);
_instance.ConsoleWriteLine();
Logger.WriteInformation(Logger.EventId.NotDefined, msg);
_instance = null;
}
}
void OnEnter(object sender, EventArgs e)
{
// check if messages to process from msmq exceeds configured limit: delay current thread until it goes back to normal levels
DelayCurrentRequestIfNecessary();
HttpContext httpContext = (sender as HttpApplication).Context;
var request = httpContext.Request;
#if WEB
DetailedLogger.Log("PCM.OnEnter {0} {1}", request.RequestType, request.Url); // category: WEB
#endif
//trace
bool traceReportEnabled;
var traceQueryString = request.QueryString["trace"];
if (!String.IsNullOrEmpty(traceQueryString))
{
traceReportEnabled = (traceQueryString == "true") ? true : false;
}
else
{
traceReportEnabled = RepositoryConfiguration.TraceReportEnabled;
}
if (traceReportEnabled)
{
var slot = Thread.GetNamedDataSlot(Tracing.OperationTraceDataSlotName);
var data = Thread.GetData(slot);
if (data == null)
{
Thread.SetData(slot, new OperationTraceCollector());
}
}
//trace
var initInfo = PortalContext.CreateInitInfo(httpContext);
// Check for forbidden paths (custom request filtering), mainly for phisycal folders in the web folder.
// The built-in Request filtering module is not capable of filtering folders only in the root, but let
// us have folders with the same name somewhere else in the Content Repository.
if (IsForbiddenFolder(initInfo))
{
AuthenticationHelper.ThrowNotFound();
}
// check if request came to a restricted site via another site
if (DenyCrossSiteAccessEnabled)
{
if (initInfo.RequestedNodeSite != null && initInfo.RequestedSite != null)
{
if (initInfo.RequestedNodeSite.DenyCrossSiteAccess && initInfo.RequestedSite.Id != initInfo.RequestedNodeSite.Id)
{
HttpContext.Current.Response.StatusCode = 404;
HttpContext.Current.Response.Flush();
HttpContext.Current.Response.End();
return;
}
}
}
// add cache-control headers and handle ismodifiedsince requests
HandleResponseForClientCache(initInfo);
PortalContext portalContext = PortalContext.Create(httpContext, initInfo);
var action = HttpActionManager.CreateAction(portalContext);
Logger.WriteVerbose("HTTP Action.", CollectLoggedProperties, portalContext);
action.Execute();
}
