public TccTransaction(TccTransactionData data, TccCoordinator <TContext> coordinator, TContext ctx)
{
// TODO: 从TransactionData中恢复数据
_context = ctx.Deserialize <TContext>(data.ContextData);
_txId = data.TxId;
_txState = data.TxState;
_lock = null;
_works = new List <TccWorkUnit <TContext> >();
_txCtx = null;
_coordinator = coordinator;
if (_coordinator != null)
{
_coordinator.NewTransaction(this);
_tracing = _coordinator.Tracing;
}
else
{
_tracing = _defaultTracing;
}
Prepare();
foreach (var a in _works)
{
a.Tracing = _tracing;
}
}
internal Database(IICDbType dbType, string connectionString)
{
_configItem = new IICDbConfigItem();
_configItem.DbType = dbType;
_configItem.ConnectionString = connectionString;
_tracing = TracingManager.GetTracing("Database.[ConnStr=" + connectionString + "]");
_perfCounters = IICPerformanceCounterFactory.GetCounters <DatabasePerfCounters>(".");
switch (_configItem.DbType)
{
case IICDbType.SqlServer2005:
_operation = new SqlServerDatabase(_configItem.ConnectionString, 120);
break;
case IICDbType.Mysql:
_operation = new MysqlDatabase(_configItem.ConnectionString, 120);
break;
case IICDbType.MysqlBatchInsert:
_operation = new MysqlBatchInsert(_configItem.ConnectionString);
break;
default:
throw new NotSupportedException(string.Format("Not Support DbType:{0} {1}", _configItem.DbType, _configItem.Name));
}
}
public TccRunningContext(Context ctx, ITracing tracing)
{
_ctx = ctx;
_tracing = tracing;
_successed = true;
_works = new List <ComboClass <TccWorkUnit <Context>, TccAction> >();
}
/// <summary>
/// 初始化属于指定服务角色的系统工作者
/// </summary>
/// <param name="role">服务角色</param>
/// <param name="setting">远程配置设置</param>
/// <param name="configurationProxy">远程配置站访问代理器</param>
/// <param name="notificationHandler">异常通知处理器</param>
/// <param name="proxy">KAE资源代理器</param>
/// <exception cref="ArgumentNullException">参数不能为空</exception>
public static void Initialize(string role, RemoteConfigurationSetting setting, IRemoteConfigurationProxy configurationProxy, ITracingNotificationHandler notificationHandler = null, IKAEResourceProxy proxy = null)
{
if (IsInitialized)
{
return;
}
if (setting == null)
{
setting = RemoteConfigurationSetting.Default;
}
if (proxy == null)
{
proxy = new KAEHostResourceProxy();
}
if (string.IsNullOrEmpty(role))
{
throw new ArgumentNullException(nameof(role));
}
if (configurationProxy == null)
{
throw new ArgumentNullException(nameof(configurationProxy));
}
SystemConfigurations.Initialize(role, setting, configurationProxy);
_tracing = TracingManager.GetTracing(typeof(SystemWorker));;
TransactionGlobal.Initialize();
_configurationProxy = configurationProxy;
_hostProxy = proxy;
TracingManager.NotificationHandler = notificationHandler ?? new RemoteLogProxy();
InitializeCore(role);
//initialize long...long memory buffer for tcp layer.
ChannelConst.Initialize();
_isInitialized = true;
IsInSpecifiedKPP = false;
}
public TccTransaction(TContext ctx, TccCoordinator <TContext> coordinator)
{
_context = ctx;
_txId = Guid.NewGuid().ToString();
_txState = TccTransactionState.New;
_lock = null;
_works = new List <TccWorkUnit <TContext> >();
_txCtx = null;
Prepare();
_coordinator = coordinator;
if (_coordinator != null)
{
_coordinator.NewTransaction(this);
_tracing = _coordinator.Tracing;
}
else
{
_tracing = _defaultTracing;
}
foreach (var a in _works)
{
a.Tracing = _tracing;
}
}
public DataManager_UnitTest()
{
fileProvider = ConfigureMoqFileProvider();
jsonProvider = ConfigureJsonProvider();
myTracing = ConfigureTracingProvider();
dataManager = new DataManager(fileProvider, jsonProvider, myTracing);
}
protected HttpClientTracingObserver(string observerName, string diagnosticName, ITracingOptions options, ITracing tracing, ILogger logger)
: base(observerName, diagnosticName, logger)
{
Options = options;
Tracing = tracing;
TextFormat = tracing.TextFormat;
Tracer = tracing.Tracer;
PathMatcher = new Regex(options.EgressIgnorePattern);
}
protected AspNetCoreTracingObserver(string observerName, ITracingOptions options, ITracing tracing, ILogger logger)
: base(observerName, DIAGNOSTIC_NAME, logger)
{
Options = options;
Tracing = tracing;
Propagation = tracing.PropagationComponent.TextFormat;
Tracer = tracing.Tracer;
PathMatcher = new Regex(options.IngressIgnorePattern);
}
/// <summary>
/// KAE宿主状态记录器
/// </summary>
/// <param name="tracing">本地日志记录器</param>
/// <param name="maximumLogCount">内部所能够包含的日志条数最大值，超过这个数目的历史数据将会自动消失</param>
public KAEStateLogger(ITracing tracing, int maximumLogCount = 1024)
{
if (tracing == null)
{
throw new ArgumentNullException("tracing");
}
_tracing = tracing;
_maximumLogCount = maximumLogCount;
_content = new Queue <string>(maximumLogCount);
}
public RpcClientObserverItem(string serverUri, string service, string method, string serviceRole)
{
ServerUri = serverUri;
Service = service;
Method = method;
ServiceRole = serviceRole;
RequestTracer = TracingManager.GetTracing(string.Format("RpcClient.{0}.{1}.Request", service, method));
ResponseTracer = TracingManager.GetTracing(string.Format("RpcClient.{0}.{1}.Response", service, method));
}
public RpcClientObserverItem(string serverUri, string service, string method, string serviceRole)
{
ServerUri = serverUri;
Service = service;
Method = method;
ServiceRole = serviceRole;
RequestTracer = TracingManager.GetTracing(string.Format("RpcClient.{0}.{1}.Request", service, method));
ResponseTracer = TracingManager.GetTracing(string.Format("RpcClient.{0}.{1}.Response", service, method));
}
public RpcServerObserverItem(string service, string method, string fromService, string fromComputer)
{
Service = service;
Method = method;
FromService = fromService;
FromComputer = fromComputer;
RequestTracer = TracingManager.GetTracing(string.Format("RpcServer.{0}.{1}.Request", service, method));
ResponseTracer = TracingManager.GetTracing(string.Format("RpcServer.{0}.{1}.Response", service, method));
}
public TccCoordinator(string transName)
{
_transName = transName;
_activeTrans = new Dictionary <string, TccTransaction <TContext> >();
_tracing = TracingManager.GetTracing("TccTransaction." + _transName);
_counter = IICPerformanceCounterFactory.GetCounters <TccTransactionPerfCounter>(transName);
_monitorThread = new Thread(MonitorProc);
_monitorThread.IsBackground = false;
_monitorThread.Name = "TccCoordinator.MonitorProc<" + _transName + ">";
}
public string InstallPackages(
string projectContent,
Dictionary <string, NuGetPackage> requestedPackages,
Dictionary <string, NuGetPackage> installedPackages,
string projectName,
ITracing tracing)
{
tracing.Debug($"Skipped processing project '{projectName}' as its type is unsupported.");
return(projectContent);
}
/// <param name="saveProjectDelegate">T1 = path, T2 = content</param>
internal void Execute(
IEnumerable <IProject> applicationProjects,
ITracing tracing,
Action <string, string> saveProjectDelegate,
Func <IProject, string> loadProjectDelegate)
{
string report;
var(projectPackages, highestVersions) = DeterminePackages(applicationProjects, loadProjectDelegate);
if (_settingConsolidatePackageVersions &&
!string.IsNullOrWhiteSpace(report = GetPackagesWithMultipleVersionsReport(projectPackages)))
{
tracing.Info(
"Multiple versions exist for one or more NuGet packages within the solution. Intent will now automatically " +
"upgrade any lower versions to the highest installed version within the solution. To disable this behaviour " +
$"change the 'Consolidate Package Versions' option in Intent in the {Identifier} module configuration." +
$"{Environment.NewLine}" +
$"{Environment.NewLine}" +
$"{report}");
ConsolidatePackageVersions(projectPackages, highestVersions);
}
foreach (var projectPackage in projectPackages)
{
if (!projectPackage.RequestedPackages.Any())
{
continue;
}
var updatedProjectContent = projectPackage.Processor.InstallPackages(
projectContent: projectPackage.Content,
requestedPackages: projectPackage.RequestedPackages,
installedPackages: projectPackage.InstalledPackages,
projectName: projectPackage.Name,
tracing: tracing);
saveProjectDelegate(projectPackage.FilePath, updatedProjectContent);
}
if (_settingWarnOnMultipleVersionsOfSamePackage &&
!_settingConsolidatePackageVersions &&
!string.IsNullOrWhiteSpace(report = GetPackagesWithMultipleVersionsReport(projectPackages)))
{
tracing.Warning(
"Multiple versions exist for one or more NuGet packages within the solution. You should consider " +
"consolidating these package versions within Visual Studio or alternatively enable the 'Consolidate " +
$"Package Versions' option in Intent in the {Identifier} module configuration." +
$"{Environment.NewLine}" +
$"{Environment.NewLine}" +
$"{report}");
}
}
public void Tracing()
{
ITracing myTracing = null;
using (IUnityContainer container = new UnityContainer())
{
UnityConfig.RegisterTypes(container);
myTracing = container.Resolve <ITracing>();
}
Assert.IsNotNull(myTracing);
}
public void Tracing()
{
ITracing myTracing = null;
using (IUnityContainer container = new UnityContainer())
{
InternationalBusinessServiceLibrary.Unity.ConfigureUnity.Configure(container);
myTracing = container.Resolve <ITracing>();
}
Assert.IsNotNull(myTracing);
}
internal Database(string configKey)
{
_configKey = configKey;
_tracing = TracingManager.GetTracing("Database." + configKey);
_perfCounters = IICPerformanceCounterFactory.GetCounters <DatabasePerfCounters>(configKey);
try {
GetInnerOperation();
} catch (Exception ex) {
SystemLog.Error(LogEventID.DatabaseFailed, ex, "Database GetFailed <{0}>", configKey);
}
}
public LRUCacheManager(string name, int cacheCount)
{
if (!Stopwatch.IsHighResolution)
{
throw new NotSupportedException();
}
_cacheName = name;
_cacheCount = cacheCount;
_counters = IICPerformanceCounterFactory.GetCounters <PerfCounters>(_cacheName);
_tracing = TracingManager.GetTracing("LRUCacheManager." + _cacheName);
}
static void Main(string[] args)
{
ServiceSettings.InitService("IICCommon");
ITracing tracing = TracingManager.GetTracing(typeof(Program));
tracing.Info("test");
LinkedNode <string> linkedNode = new LinkedNode <string>();
linkedNode.Value = "1";
linkedNode.AddNext("2");
linkedNode.AddNext("3");
foreach (string str in linkedNode.GetValues())
{
Console.WriteLine(str);
}
Console.ReadLine();
}
public ParallelQueue(string queueName, int maxBatchCount, int maxIdleMs, Action <K, V[]> dequeueAction)
{
_queueName = queueName;
_maxBatchCount = maxBatchCount;
_maxIdleMs = maxIdleMs;
_dequeueAction = dequeueAction;
_tracing = TracingManager.GetTracing("ParalelQueue." + queueName);
_perfCounters = IICPerformanceCounterFactory.GetCounters <ParallelQueuePerfCounters>(queueName);
_thread = new Thread(ThreadProc);
_thread.IsBackground = true;
_thread.Start();
int max;
int foo;
ThreadPool.GetMaxThreads(out max, out foo);
_defendWorkerThreadCounts = max / 8;
}
public LazyQueue(string queueName, int maxBatchCount, int maxIdleMs, Action <T[]> dequeueAction, bool enabledCounters)
{
_queueName = queueName;
_batchCount = maxBatchCount;
_idleMs = maxIdleMs;
_dequeueAction = dequeueAction;
_capacity = 65536;
_lastTick = Environment.TickCount;
_tracing = TracingManager.GetTracing("LazyQueue." + queueName);
if (enabledCounters)
{
_counters = IICPerformanceCounterFactory.GetCounters <LazyQueuePerfCounters>(queueName);
}
_thread = new Thread(new ThreadStart(ThreadProc));
_thread.Name = string.Format("LazyQueue<{0}>:{1}", typeof(T).Name, queueName);
_thread.IsBackground = true;
_thread.Start();
}
public string InstallPackages(
string projectContent,
Dictionary <string, NuGetPackage> requestedPackages,
Dictionary <string, NuGetPackage> installedPackages,
string projectName,
ITracing tracing)
{
// This format is now unsupported, but we will show a warnings for missing packages.
var installationsRequired = requestedPackages
.Where(x => !installedPackages.ContainsKey(x.Key))
.ToArray();
var upgradesRequired = requestedPackages
.Where(x => installedPackages.TryGetValue(x.Key, out var nuGetPackage) && nuGetPackage.Version.MinVersion < x.Value.Version.MinVersion)
.ToArray();
if (!installationsRequired.Any() && !upgradesRequired.Any())
{
return(projectContent);
}
var sb = new StringBuilder();
sb.AppendLine($"Installations and upgrades of NuGet packages is not supported for project {projectName}, only .csproj files using " +
"PackageReferences are. Refer to https://blog.nuget.org/20180409/migrate-packages-config-to-package-reference.html for information " +
"on how to upgrade this existing project. You can alternatively manually install/upgrade the following packages using Visual Studio:");
foreach (var item in installationsRequired)
{
sb.AppendLine($" - Install {item.Key} version {item.Value.Version}");
}
foreach (var item in upgradesRequired)
{
sb.AppendLine($" - Upgrade version of {item.Key} from {installedPackages[item.Key]} to {item.Value.Version}");
}
tracing.Warning(sb.ToString());
return(projectContent);
}
/// <summary>
/// 为KPP专门设计的初始化SystemWorker的函数
/// </summary>
/// <param name="role">服务角色</param>
/// <param name="proxy">KAE资源代理器</param>
/// <param name="settings">KJFramework网络层设置集</param>
/// <param name="appUniqueId">APP唯一编号</param>
/// <exception cref="ArgumentNullException">参数不能为空</exception>
internal static void InitializeForKPP(string role, IKAEResourceProxy proxy, ChannelInternalConfigSettings settings, Guid appUniqueId)
{
if (IsInitialized)
{
return;
}
if (string.IsNullOrEmpty(role))
{
throw new ArgumentNullException(nameof(role));
}
_hostProxy = proxy;
_appUniqueId = appUniqueId;
_configurationProxy = new KPPConfigurationProxy(proxy);
SystemConfigurations.Initialize(role, RemoteConfigurationSetting.Default, _configurationProxy);
_tracing = TracingManager.GetTracing(typeof(SystemWorker));;
TransactionGlobal.Initialize();
//Regist("LGS", new LGSProtocolStack());
TracingManager.NotificationHandler = new RemoteLogProxy();
InitializeCore(role);
//initialize long...long memory buffer for tcp layer.
ChannelConst.Initialize(settings);
_isInitialized = true;
IsInSpecifiedKPP = true;
}
public HttpClientCoreObserver(ITracingOptions options, ITracing tracing, ILogger <HttpClientCoreObserver> logger = null)
: base(OBSERVER_NAME, DIAGNOSTIC_NAME, options, tracing, logger)
{
}
public AspNetCoreMvcActionObserver(ITracingOptions options, ITracing tracing, ILogger <AspNetCoreMvcActionObserver> logger = null)
: base(OBSERVER_NAME, options, tracing, logger)
{
}
public string InstallPackages(
string projectContent,
Dictionary <string, NuGetPackage> requestedPackages,
Dictionary <string, NuGetPackage> installedPackages,
string projectName,
ITracing tracing)
{
var document = XDocument.Parse(projectContent);
var(prefix, namespaceManager, namespaceName) = document.GetNamespaceManager();
var packageReferenceItemGroup = document.XPathSelectElement($"/{prefix}:Project/{prefix}:ItemGroup[{prefix}:PackageReference]", namespaceManager);
// Try add after last ItemGroup, otherwise last PropertyGroup
if (packageReferenceItemGroup == null)
{
var element = document.XPathSelectElements($"/{prefix}:Project/{prefix}:ItemGroup", namespaceManager).LastOrDefault() ??
document.XPathSelectElements($"/{prefix}:Project/{prefix}:PropertyGroup", namespaceManager).LastOrDefault();
element?.AddAfterSelf(packageReferenceItemGroup = new XElement(XName.Get("ItemGroup", namespaceName)));
}
// Otherwise, add to Project element
if (packageReferenceItemGroup == null)
{
var projectElement = document.XPathSelectElement($"/{prefix}:Project", namespaceManager);
if (projectElement == null)
{
throw new Exception("Project element not found.");
}
projectElement.AddFirst(packageReferenceItemGroup = new XElement(XName.Get("ItemGroup", namespaceName)));
}
foreach (var requestedPackage in requestedPackages)
{
var packageId = requestedPackage.Key;
var package = requestedPackage.Value;
var packageReferenceElement = packageReferenceItemGroup.XPathSelectElement($"{prefix}:PackageReference[@Include='{packageId}']", namespaceManager);
if (packageReferenceElement == null)
{
tracing.Info($"Installing {packageId} {package.Version} into project {projectName}");
packageReferenceItemGroup.Add(packageReferenceElement = new XElement(
XName.Get("PackageReference", namespaceName),
new XAttribute("Include", packageId),
new XElement(XName.Get("Version", namespaceName), package.Version)));
}
var versionElement = packageReferenceElement.XPathSelectElement($"{prefix}:Version", namespaceManager);
if (versionElement == null)
{
throw new Exception("Missing version element from PackageReference element.");
}
if (SemanticVersion.Parse(versionElement.Value) >= package.Version)
{
continue;
}
tracing.Info($"Upgrading {packageId} from {versionElement.Value} to {package.Version} in project {projectName}");
versionElement.SetValue(package.Version);
}
SortAlphabetically(packageReferenceItemGroup);
return(Format(document));
}
public TraceExporter(ITraceExporterOptions options, ITracing tracing, ILogger <TraceExporter> logger = null)
{
_options = options;
_logger = logger;
_exportComponent = tracing.ExportComponent;
}
public TracingLogProcessor(ITracingOptions options, ITracing tracing)
{
this.options = options;
this.tracing = tracing;
}
public DataManager(IPersistentManager fileProvider, IDataProvider jsonProvider, ITracing myTracing)
{
this._fileProvider = fileProvider;
this._jsonProvider = jsonProvider;
this._myTracing = myTracing;
}
public FortuneRepository(FortuneContext db, ITracing tracing, ILogger <FortuneRepository> logger)
{
_db = db;
_tracing = tracing;
_logger = logger;
}
