public VoxelTerrain(IChunkFactory chunkFactory, Volume terrainSize, Volume chunkSize, uint chunkGeneratorCount,
Vector3F pos)
{
_chunkFactory = chunkFactory;
_terrainSize = terrainSize;
_chunkSize = chunkSize;
_previousPosition = GetFirstChunkWorldPosition(pos);
InitializeChunkGenerators(chunkGeneratorCount);
InitializeChunks();
}
public StreamingOnDemandProcessingResult(AspNetCore.ReportingServices.ReportIntermediateFormat.ReportSnapshot newOdpSnapshot, AspNetCore.ReportingServices.ReportIntermediateFormat.Persistence.ChunkManager.OnDemandProcessingManager chunkManager, bool newOdpSnapshotChanged, IChunkFactory createChunkFactory, ParameterInfoCollection parameters, int autoRefresh, int numberOfPages, ProcessingMessageList warnings, bool eventInfoChanged, EventInformation newEventInfo, PaginationMode updatedPaginationMode, ReportProcessingFlags updatedProcessingFlags, UserProfileState usedUserProfileState, ExecutionLogContext executionLogContext)
: base(createChunkFactory, newOdpSnapshot.DefinitionTreeHasDocumentMap, newOdpSnapshot.HasShowHide || newOdpSnapshot.HasUserSortFilter, parameters, autoRefresh, numberOfPages, warnings, eventInfoChanged, newEventInfo, updatedPaginationMode, updatedProcessingFlags, usedUserProfileState, executionLogContext)
{
}
public DataSetContext(string targetChunkNameInSnapshot, string cachedDataChunkName, bool mustCreateDataChunk, IRowConsumer consumerRequest, ICatalogItemContext itemContext, RuntimeDataSourceInfoCollection dataSources, string requestUserName, DateTime executionTimeStamp, ParameterInfoCollection parameters, IChunkFactory createChunkFactory, ReportProcessing.ExecutionType interactiveExecution, CultureInfo culture, UserProfileState allowUserProfileState, UserProfileState initialUserProfileState, IProcessingDataExtensionConnection createDataExtensionInstanceFunction, CreateAndRegisterStream createStreamCallbackForScalability, ReportRuntimeSetup dataSetRuntimeSetup, IJobContext jobContext, IDataProtection dataProtection)
{
this.m_targetChunkNameInSnapshot = targetChunkNameInSnapshot;
this.m_cachedDataChunkName = cachedDataChunkName;
this.m_mustCreateDataChunk = mustCreateDataChunk;
this.m_consumerRequest = consumerRequest;
this.m_itemContext = itemContext;
this.m_dataSources = dataSources;
this.m_requestUserName = requestUserName;
this.m_executionTimeStamp = executionTimeStamp;
this.m_parameters = parameters;
this.m_createChunkFactory = createChunkFactory;
this.m_interactiveExecution = interactiveExecution;
this.m_culture = culture;
this.m_allowUserProfileState = allowUserProfileState;
this.m_initialUserProfileState = initialUserProfileState;
this.m_createDataExtensionInstanceFunction = createDataExtensionInstanceFunction;
this.m_createStreamCallbackForScalability = createStreamCallbackForScalability;
this.m_dataSetRuntimeSetup = dataSetRuntimeSetup;
this.m_jobContext = jobContext;
this.m_dataProtection = dataProtection;
}
public RenderReportYukonDefinitionOnly(ProcessingContext pc, RenderingContext rc, DateTime executionTimeStamp, ReportProcessing processing, IChunkFactory yukonCompiledDefinition)
: base(pc, rc, executionTimeStamp, processing, yukonCompiledDefinition)
{
}
public RenderingContext(string rendererID, AspNetCore.ReportingServices.ReportProcessing.ReportSnapshot reportSnapshot, IChunkFactory chunkFactory, EventInformation eventInfo)
{
this.m_rendererID = rendererID;
this.m_isSubReportContext = false;
this.m_oldReportSnapshot = reportSnapshot;
this.InitEventInfo(eventInfo);
if (chunkFactory != null)
{
this.m_chunkManager = new RenderingChunkManager(rendererID, chunkFactory);
}
}
public RenderReportOdpLiveAndCacheData(ProcessingContext pc, RenderingContext rc, DateTime executionTimeStamp, IConfiguration configuration, IChunkFactory metaDataChunkFactory)
: base(pc, rc, executionTimeStamp, configuration)
{
Global.Tracer.Assert(metaDataChunkFactory != null, "Must supply a IChunkFactory to store the cached data");
this.m_metaDataChunkFactory = metaDataChunkFactory;
}
public YukonProcessingResult(bool renderingInfoChanged, IChunkFactory createChunkFactory, bool hasInteractivity, RenderingInfoManager renderingInfoManager, bool eventInfoChanged, EventInformation newEventInfo, ParameterInfoCollection parameters, ProcessingMessageList warnings, int autoRefresh, int numberOfPages, PaginationMode updatedPaginationMode, ReportProcessingFlags updatedProcessingFlags, UserProfileState usedUserProfileState, ExecutionLogContext executionLogContext)
: base(createChunkFactory, false, hasInteractivity, parameters, autoRefresh, numberOfPages, warnings, eventInfoChanged, newEventInfo, updatedPaginationMode, updatedProcessingFlags, usedUserProfileState, executionLogContext)
{
this.m_snapshotChanged = this.Initialize(null, null, renderingInfoChanged, renderingInfoManager);
}
public PublishingContext(ICatalogItemContext catalogContext, byte[] reportDefinition, IChunkFactory createChunkFactory, AppDomain compilationTempAppDomain, bool generateExpressionHostWithRefusedPermissions, ReportProcessingFlags processingFlags, ReportProcessing.CheckSharedDataSource checkDataSourceCallback, ReportProcessing.ResolveTemporaryDataSource resolveTemporaryDataSourceCallback, DataSourceInfoCollection originalDataSources, ReportProcessing.CheckSharedDataSet checkDataSetCallback, ReportProcessing.ResolveTemporaryDataSet resolveTemporaryDataSetCallback, DataSetInfoCollection originalDataSets, IConfiguration configuration, IDataProtection dataProtection, bool isInternalRepublish, bool isPackagedReportArchive, bool isRdlx)
: base(PublishingContextKind.Full, catalogContext, createChunkFactory, compilationTempAppDomain, generateExpressionHostWithRefusedPermissions, processingFlags, checkDataSourceCallback, resolveTemporaryDataSourceCallback, originalDataSources, checkDataSetCallback, resolveTemporaryDataSetCallback, originalDataSets, configuration, dataProtection, isInternalRepublish, isPackagedReportArchive, isRdlx, traceAtomicScopes : false)
{
m_definition = reportDefinition;
}
public static void EnsureLookupStorageSetup(OnDemandMetadata odpMetadata, IChunkFactory chunkFactory, bool openExisting, int rifCompatVersion, bool prohibitSerializableValues)
{
if (odpMetadata.LookupScalabilityCache == null)
{
new AppendOnlySpaceManager();
IStreamHandler streamHandler = OnDemandProcessingManager.BuildChunkStreamHandler("LookupInfo", AspNetCore.ReportingServices.ReportProcessing.ReportProcessing.ReportChunkTypes.LookupInfo, chunkFactory, openExisting);
IStorage storage = new RIFAppendOnlyStorage(streamHandler, (IScalabilityObjectCreator)(object)default(LookupRIFObjectCreator), LookupReferenceCreator.Instance, null, openExisting, rifCompatVersion, prohibitSerializableValues);
odpMetadata.LookupScalabilityCache = new LookupScalabilityCache(odpMetadata.LookupPartitionManager, storage);
}
}
public static void EnsureGroupTreeStorageSetup(OnDemandMetadata odpMetadata, IChunkFactory chunkFactory, GlobalIDOwnerCollection globalIDOwnerCollection, bool openExisting, int rifCompatVersion, bool prohibitSerializableValues)
{
if (odpMetadata.GroupTreeScalabilityCache == null)
{
IStreamHandler streamHandler = OnDemandProcessingManager.BuildChunkStreamHandler("GroupTree", AspNetCore.ReportingServices.ReportProcessing.ReportProcessing.ReportChunkTypes.Main, chunkFactory, openExisting);
IStorage storage = new RIFAppendOnlyStorage(streamHandler, (IScalabilityObjectCreator)(object)default(GroupTreeRIFObjectCreator), GroupTreeReferenceCreator.Instance, globalIDOwnerCollection, openExisting, rifCompatVersion, prohibitSerializableValues);
odpMetadata.GroupTreeScalabilityCache = new GroupTreeScalabilityCache(odpMetadata.GroupTreePartitionManager, storage);
}
}
public static GlobalIDOwnerCollection DeserializeOdpReportSnapshot(ProcessingContext pc, IChunkFactory originalSnapshotChunks, ProcessingErrorContext errorContext, bool fetchSubreports, bool deserializeGroupTree, IConfiguration configuration, ref OnDemandMetadata odpMetadata, out Report report)
{
GlobalIDOwnerCollection globalIDOwnerCollection = new GlobalIDOwnerCollection();
report = AspNetCore.ReportingServices.ReportProcessing.ReportProcessing.DeserializeKatmaiReport(pc.ChunkFactory, true, globalIDOwnerCollection);
IChunkFactory chunkFactory = originalSnapshotChunks ?? pc.ChunkFactory;
if (odpMetadata == null)
{
odpMetadata = OnDemandProcessingManager.DeserializeOnDemandMetadata(chunkFactory, globalIDOwnerCollection);
}
if (pc.Parameters != null)
{
pc.Parameters.StoreLabels();
}
if (fetchSubreports)
{
AspNetCore.ReportingServices.ReportProcessing.ReportProcessing.FetchSubReports(report, pc.ChunkFactory, errorContext, odpMetadata, pc.ReportContext, pc.OnDemandSubReportCallback, 0, true, false, globalIDOwnerCollection, pc.QueryParameters);
if (deserializeGroupTree)
{
OnDemandProcessingManager.DeserializeGroupTree(report, chunkFactory, globalIDOwnerCollection, configuration, ref odpMetadata);
}
}
odpMetadata.GlobalIDOwnerCollection = globalIDOwnerCollection;
return(globalIDOwnerCollection);
}
public static string StoreImageDataInChunk(AspNetCore.ReportingServices.ReportProcessing.ReportProcessing.ReportChunkTypes chunkType, byte[] imageData, string mimeType, OnDemandMetadata odpMetadata, IChunkFactory chunkFactory)
{
string text = ImageHelper.GenerateImageStreamName();
ReportSnapshot reportSnapshot = odpMetadata.ReportSnapshot;
using (Stream stream = chunkFactory.CreateChunk(text, chunkType, mimeType))
{
stream.Write(imageData, 0, imageData.Length);
return(text);
}
}
protected ProcessingContext CreateProcessingContext(ParameterInfoCollection reportParameters, IEnumerable dataSources, DatasourceCredentialsCollection credentials, IChunkFactory chunkFactory, CreateAndRegisterStream createStreamCallback, SubreportCallbackHandler subreportHandler)
{
RuntimeDataSourceInfoCollection dataSourceInfoColl = null;
RuntimeDataSetInfoCollection dataSetInfoColl = null;
this.GetAllReportDataSourcesAndSharedDataSets(out dataSourceInfoColl, out dataSetInfoColl);
return(this.m_dataRetrieval.CreateProcessingContext(this.m_itemContext, reportParameters, dataSources, dataSourceInfoColl, dataSetInfoColl, this.GetCompiledDataSet, credentials, subreportHandler.OnDemandSubReportCallback, new GetResourceForLocalService(this.Catalog), chunkFactory, this.m_reportRuntimeSetupHandler.ReportRuntimeSetup, createStreamCallback));
}
private void OnGetSubReportDataSources(ICatalogItemContext itemContext, string subreportPath, ReportProcessing.NeedsUpgrade upgradeCheck, out ICatalogItemContext subreportContext, out IChunkFactory getCompiledDefinition, out DataSourceInfoCollection dataSources, out DataSetInfoCollection dataSets)
{
subreportPath = this.NormalizeSubReportPath(subreportPath);
subreportContext = itemContext.GetSubreportContext(subreportPath);
RSTrace.ReportPreviewTracer.Trace(TraceLevel.Info, "Getting datasources information for {0}.", subreportContext.ItemPathAsString);
ControlSnapshot controlSnapshot = default(ControlSnapshot);
PublishingResult compiledReport = this.GetCompiledReport((PreviewItemContext)subreportContext, false, out controlSnapshot);
getCompiledDefinition = controlSnapshot;
dataSources = this.ResolveSharedDataSources(compiledReport.DataSources);
dataSets = this.ResolveSharedDataSets(compiledReport.SharedDataSets);
}
private void OnGetSubReportDefinition(ICatalogItemContext reportContext, string subreportPath, string newChunkName, ReportProcessing.NeedsUpgrade upgradeCheck, ParameterInfoCollection parentQueryParameters, out ICatalogItemContext subreportContext, out string description, out IChunkFactory chunkFactory, out ParameterInfoCollection parameters)
{
if (reportContext == null)
{
throw new ArgumentException("OnGetSubReportDefinition: Invalid report context");
}
if (upgradeCheck(ReportProcessingFlags.OnDemandEngine))
{
throw new Exception("Subreport definition is not compatible with this version of viewer controls");
}
subreportContext = reportContext.GetSubreportContext(subreportPath);
ControlSnapshot controlSnapshot = default(ControlSnapshot);
PublishingResult compiledReport = this.GetCompiledReport((PreviewItemContext)subreportContext, false, out controlSnapshot);
controlSnapshot.PrepareExecutionSnapshot(this.m_executionSession.Snapshot, newChunkName);
description = compiledReport.ReportDescription;
chunkFactory = controlSnapshot;
parameters = compiledReport.Parameters;
}
public PublishingContext(ICatalogItemContext catalogContext, byte[] reportDefinition, IChunkFactory createChunkFactory, AppDomain compilationTempAppDomain, bool generateExpressionHostWithRefusedPermissions, ReportProcessingFlags processingFlags, IConfiguration configuration, IDataProtection dataProtection)
: this(catalogContext, reportDefinition, createChunkFactory, compilationTempAppDomain, generateExpressionHostWithRefusedPermissions, processingFlags, null, null, null, null, null, null, configuration, dataProtection, isInternalRepublish : false, isPackagedReportArchive : false, isRdlx : false)
{
}
private static IStreamHandler BuildChunkStreamHandler(string chunkName, AspNetCore.ReportingServices.ReportProcessing.ReportProcessing.ReportChunkTypes chunkType, IChunkFactory chunkFactory, bool openExisting)
{
return(new ChunkFactoryStreamHandler(chunkName, chunkType, chunkFactory, openExisting));
}
public YukonProcessingResult(ReportSnapshot newSnapshot, ChunkManager.ProcessingChunkManager chunkManager, IChunkFactory createChunkFactory, ParameterInfoCollection parameters, int autoRefresh, int numberOfPages, ProcessingMessageList warnings, bool renderingInfoChanged, RenderingInfoManager renderingInfoManager, bool eventInfoChanged, EventInformation newEventInfo, PaginationMode updatedPaginationMode, ReportProcessingFlags updatedProcessingFlags, UserProfileState usedUserProfileState, ExecutionLogContext executionLogContext)
: base(createChunkFactory, newSnapshot.HasDocumentMap, newSnapshot.HasShowHide, parameters, autoRefresh, numberOfPages, warnings, eventInfoChanged, newEventInfo, updatedPaginationMode, updatedProcessingFlags, usedUserProfileState, executionLogContext)
{
this.m_snapshotChanged = this.Initialize(newSnapshot, chunkManager, renderingInfoChanged, renderingInfoManager);
}
public static Stream OpenExistingDocumentMapStream(OnDemandMetadata odpMetadata, ICatalogItemContext reportContext, IChunkFactory chunkFactory)
{
Stream stream = null;
if (!odpMetadata.ReportSnapshot.CanUseExistingDocumentMapChunk(reportContext))
{
return(null);
}
string text = default(string);
return(chunkFactory.GetChunk("DocumentMap", AspNetCore.ReportingServices.ReportProcessing.ReportProcessing.ReportChunkTypes.Interactivity, ChunkMode.Open, out text));
}
internal static string StoreImageDataInChunk(Microsoft.ReportingServices.ReportProcessing.ReportProcessing.ReportChunkTypes chunkType, byte[] imageData, string mimeType, OnDemandMetadata odpMetadata, IChunkFactory chunkFactory)
{
string text = GenerateImageStreamName();
_ = odpMetadata.ReportSnapshot;
using (Stream stream = chunkFactory.CreateChunk(text, chunkType, mimeType))
{
stream.Write(imageData, 0, imageData.Length);
return text;
}
}
internal ChunkFactoryStreamHandler(string chunkName, Microsoft.ReportingServices.ReportProcessing.ReportProcessing.ReportChunkTypes chunkType, IChunkFactory chunkFactory, bool existingChunk)
{
m_chunkName = chunkName;
m_chunkType = chunkType;
m_chunkFactory = chunkFactory;
m_existingChunk = existingChunk;
}
public override ProcessingContext CreateProcessingContext(PreviewItemContext itemContext, ParameterInfoCollection parameters, IEnumerable dataSources, RuntimeDataSourceInfoCollection dataSourceInfoColl, RuntimeDataSetInfoCollection dataSetInfoColl, SharedDataSetCompiler sharedDataSetCompiler, DatasourceCredentialsCollection credentials, ReportProcessing.OnDemandSubReportCallback subReportCallback, IGetResource getResourceFunction, IChunkFactory chunkFactory, ReportRuntimeSetup runtimeSetup, AspNetCore.ReportingServices.Interfaces.CreateAndRegisterStream createStreamCallback)
{
return(new ProcessingContextForDataSets(itemContext, parameters, new DataSourceCollectionWrapper((ReportDataSourceCollection)dataSources), subReportCallback, this.m_subreportDataCallback, getResourceFunction, chunkFactory, runtimeSetup, (AspNetCore.ReportingServices.Interfaces.CreateAndRegisterStream)createStreamCallback));
}
public abstract ProcessingContext CreateProcessingContext(PreviewItemContext itemContext, ParameterInfoCollection parameters, IEnumerable dataSources, RuntimeDataSourceInfoCollection dataSourceInfoColl, RuntimeDataSetInfoCollection dataSetInfoColl, SharedDataSetCompiler sharedDataSetCompiler, DatasourceCredentialsCollection credentials, ReportProcessing.OnDemandSubReportCallback subReportCallback, IGetResource getResourceFunction, IChunkFactory chunkFactory, ReportRuntimeSetup runtimeSetup, CreateAndRegisterStream createStreamCallback);
public ImageCacheManager(OnDemandMetadata odpMetadata, IChunkFactory chunkFactory)
{
m_odpMetadata = odpMetadata;
m_chunkFactory = chunkFactory;
}
public ChunkFactoryAdapter(IChunkFactory aFactory)
{
this.m_chunkFactory = aFactory;
}
protected PublishingContextBase(PublishingContextKind publishingContextKind, ICatalogItemContext catalogContext, IChunkFactory createChunkFactory, AppDomain compilationTempAppDomain, bool generateExpressionHostWithRefusedPermissions, ReportProcessingFlags processingFlags, AspNetCore.ReportingServices.ReportProcessing.ReportProcessing.CheckSharedDataSource checkDataSourceCallback, AspNetCore.ReportingServices.ReportProcessing.ReportProcessing.ResolveTemporaryDataSource resolveTemporaryDataSourceCallback, DataSourceInfoCollection originalDataSources, AspNetCore.ReportingServices.ReportProcessing.ReportProcessing.CheckSharedDataSet checkDataSetCallback, AspNetCore.ReportingServices.ReportProcessing.ReportProcessing.ResolveTemporaryDataSet resolveTemporaryDataSetCallback, DataSetInfoCollection originalDataSets, IConfiguration configuration, IDataProtection dataProtection, bool isInternalRepublish, bool isPackagedReportArchive, bool isRdlx, bool traceAtomicScopes)
{
this.m_publishingContextKind = publishingContextKind;
this.m_catalogContext = catalogContext;
this.m_createChunkFactory = createChunkFactory;
this.m_compilationTempAppDomain = compilationTempAppDomain;
this.m_generateExpressionHostWithRefusedPermissions = generateExpressionHostWithRefusedPermissions;
this.m_processingFlags = processingFlags;
this.m_checkDataSourceCallback = checkDataSourceCallback;
this.m_checkDataSetCallback = checkDataSetCallback;
this.m_resolveTemporaryDataSourceCallback = resolveTemporaryDataSourceCallback;
this.m_resolveTemporaryDataSetCallback = resolveTemporaryDataSetCallback;
this.m_originalDataSources = originalDataSources;
this.m_originalDataSets = originalDataSets;
this.m_configuration = configuration;
this.m_dataProtection = dataProtection;
this.m_isInternalRepublish = isInternalRepublish;
this.m_traceAtomicScopes = traceAtomicScopes;
this.m_isPackagedReportArchive = isPackagedReportArchive;
this.m_isRdlx = isRdlx;
this.m_publishingVersioning = new PublishingVersioning(this.m_configuration, this);
}
public RenderReportYukonReprocessSnapshot(ProcessingContext pc, RenderingContext rc, ReportProcessing processing, IChunkFactory originalSnapshotChunks)
: base(pc, rc, processing)
{
this.m_originalSnapshotChunks = originalSnapshotChunks;
}
public RenderReportYukonInitial(ProcessingContext pc, RenderingContext rc, DateTime executionTimeStamp, ReportProcessing processing, IChunkFactory yukonCompiledDefinition)
: base(pc, rc, processing)
{
this.m_executionTimeStamp = executionTimeStamp;
this.m_yukonCompiledDefinition = yukonCompiledDefinition;
}
internal RenderingContext(string rendererID, Microsoft.ReportingServices.ReportProcessing.ReportSnapshot reportSnapshot, IChunkFactory chunkFactory, EventInformation eventInfo)
{
m_rendererID = rendererID;
m_isSubReportContext = false;
m_oldReportSnapshot = reportSnapshot;
InitEventInfo(eventInfo);
if (chunkFactory != null)
{
m_chunkManager = new RenderingChunkManager(rendererID, chunkFactory);
}
}
internal ProcessingContext(ICatalogItemContext reportContext, string requestUserName, ParameterInfoCollection parameters, ReportProcessing.OnDemandSubReportCallback subReportCallback, IGetResource getResourceFunction, IChunkFactory createChunkFactory, ReportProcessing.ExecutionType interactiveExecution, CultureInfo culture, UserProfileState allowUserProfileState, UserProfileState initialUserProfileState, ReportRuntimeSetup reportRuntimeSetup, CreateAndRegisterStream createStreamCallback, bool isHistorySnapshot, IJobContext jobContext, IExtensionFactory extFactory, IDataProtection dataProtection)
{
Global.Tracer.Assert(reportContext != null, "(null != reportContext)");
m_reportContext = reportContext;
m_requestUserName = requestUserName;
m_parameters = parameters;
m_queryParameters = m_parameters.GetQueryParameters();
m_subReportCallback = subReportCallback;
m_getResourceFunction = getResourceFunction;
m_chunkFactory = createChunkFactory;
m_interactiveExecution = interactiveExecution;
m_userLanguage = culture;
m_allowUserProfileState = allowUserProfileState;
m_initialUserProfileState = initialUserProfileState;
m_reportRuntimeSetup = reportRuntimeSetup;
m_createStreamCallback = createStreamCallback;
m_isHistorySnapshot = isHistorySnapshot;
ChunkFactoryAdapter @object = new ChunkFactoryAdapter(m_chunkFactory);
m_createReportChunkCallback = @object.CreateReportChunk;
m_jobContext = jobContext;
m_extFactory = extFactory;
m_dataProtection = dataProtection;
}
public PublishingContext(ICatalogItemContext catalogContext, byte[] datasetDefinition, IChunkFactory createChunkFactory, AppDomain compilationTempAppDomain, bool generateExpressionHostWithRefusedPermissions, ReportProcessing.CheckSharedDataSource checkDataSourceCallback, IConfiguration configuration)
: base(PublishingContextKind.SharedDataSet, catalogContext, createChunkFactory, compilationTempAppDomain, generateExpressionHostWithRefusedPermissions, ReportProcessingFlags.NotSet, checkDataSourceCallback, null, null, null, null, null, configuration, null, isInternalRepublish: false, isPackagedReportArchive: false, isRdlx: false, traceAtomicScopes: false)
{
m_definition = datasetDefinition;
}
