public NodeService(
INodeRepository nodeRepository,
IReadingRepository readingRepository)
{
this.nodeRepository = nodeRepository;
this.readingRepository = readingRepository;
}
public Service(
INodeRepository nodeRepository,
IMapper mapper)
{
_nodeRepository = nodeRepository;
_mapper = mapper;
}
public static void CoreAutoFacInit()
{
var builder = new ContainerBuilder();
HttpConfiguration config = GlobalConfiguration.Configuration;
SetupResolveRules(builder);
////注册所有的Controllers
//builder.RegisterControllers(Assembly.GetExecutingAssembly()).PropertiesAutowired();
//注册所有的ApiControllers
builder.RegisterApiControllers(Assembly.GetExecutingAssembly()).PropertiesAutowired();
var container = builder.Build();
//注册api容器需要使用HttpConfiguration对象
config.DependencyResolver = new AutofacWebApiDependencyResolver(container);
DependencyResolver.SetResolver(new AutofacDependencyResolver(container));
INodeRepository node = container.Resolve <INodeRepository>();
IUserRepository user = container.Resolve <IUserRepository>();
ITaskRepository task = container.Resolve <ITaskRepository>();
ITaskVersionRepository taskversion = container.Resolve <ITaskVersionRepository>();
INodeMonitorRepository nodemonitor = container.Resolve <INodeMonitorRepository>();
GlobalConfig.MonitorList.Add(new NodeHeartBeatMonitor(node, user, task, taskversion));
GlobalConfig.MonitorList.Add(new MonitorPluginMonitor(node, user, nodemonitor));
}
public async Task <IActionResult> SyncPartitionToCluster([FromServices] INodeRepository nodeRepository,
[FromServices] ITenantRepository tenantRepository)
{
//DB側の情報を取得
var nodes = nodeRepository.GetAll();
foreach (Node node in nodes)
{
bool result = await clusterManagementLogic.UpdatePartitionLabelAsync(node.Name, node.Partition);
if (result == false)
{
//DBからノードを取っているため、名前ミスで失敗する可能性はないハズ。ダメだったら例外扱い。
return(JsonError(HttpStatusCode.ServiceUnavailable, "Failed to update partitions. Please contact your server administrator."));
}
await clusterManagementLogic.UpdateTensorBoardEnabledLabelAsync(node.Name, node.TensorBoardEnabled);
await clusterManagementLogic.UpdateNotebookEnabledLabelAsync(node.Name, node.NotebookEnabled);
// まずは全てのアサイン情報を削除する
var tenants = tenantRepository.GetAllTenants();
foreach (Tenant tenant in tenants)
{
await clusterManagementLogic.UpdateTenantEnabledLabelAsync(node.Name, tenant.Name, false);
}
// アクセスレベルが "Disable" 以外であれば、アクセス可能なテナント情報の同期を行う
if (node.AccessLevel != NodeAccessLevel.Disabled)
{
// KQI管理者用名前空間の実行を許可する
await clusterManagementLogic.UpdateTenantEnabledLabelAsync(node.Name, containerManageOptions.KqiAdminNamespace, true);
// アクセスレベルが "Private" の場合、可能なテナント一覧を取得する
if (node.AccessLevel == NodeAccessLevel.Private)
{
tenants = nodeRepository.GetAssignedTenants(node.Id);
}
// テナント情報をアサインする
if (tenants != null)
{
foreach (Tenant tenant in tenants)
{
bool ret = clusterManagementLogic.UpdateTenantEnabledLabelAsync(node.Name, tenant.Name, true).Result;
if (!ret)
{
LogError($"ノード [{node.Name}] にテナント [{tenant.Name}] のアクセス許可を Cluster(k8s) へ同期させる処理に失敗しました。");
}
}
}
}
else
{
// アクセスレベルが "Disable" の場合、KQI管理者用名前空間の実行を拒否する
await clusterManagementLogic.UpdateTenantEnabledLabelAsync(node.Name, containerManageOptions.KqiAdminNamespace, false);
}
}
return(JsonOK(nodes.Select(n => new IndexOutputModel(n))));
}
public SemanticNetworkService(
[NotNull] INodeRepository nodeRepository,
[NotNull] IVergeRepository vergeRepository,
[NotNull] ITypeRepository <NotionType> notionTypeRepository,
[NotNull] ITypeRepository <RelationType> relationTypeRepository)
{
if (nodeRepository == null)
{
throw new ArgumentNullException(nameof(nodeRepository));
}
if (vergeRepository == null)
{
throw new ArgumentNullException(nameof(vergeRepository));
}
if (notionTypeRepository == null)
{
throw new ArgumentNullException(nameof(notionTypeRepository));
}
if (relationTypeRepository == null)
{
throw new ArgumentNullException(nameof(relationTypeRepository));
}
_nodeRepository = nodeRepository;
_vergeRepository = vergeRepository;
_notionTypeRepository = notionTypeRepository;
_relationTypeRepository = relationTypeRepository;
}
public NodeHeartBeatMonitor(INodeRepository noderespostory, IUserRepository userrespostory, ITaskRepository taskrespostory, ITaskVersionRepository taskVersionrepostory)
{
nodeRep = noderespostory;
userRep = userrespostory;
taskRep = taskrespostory;
taskVersionRep = taskVersionrepostory;
}
/// <summary>
/// コンストラクタ
/// </summary>
public ClusterManagementLogic(
ICommonDiLogic commonDiLogic,
IUserRepository userRepository,
INodeRepository nodeRepository,
ITensorBoardContainerRepository tensorBoardContainerRepository,
IClusterManagementService clusterManagementService,
IUnitOfWork unitOfWork,
ILoginLogic loginLogic,
IGitLogic gitLogic,
IRegistryLogic registryLogic,
IVersionLogic versionLogic,
IOptions <ContainerManageOptions> containerOptions,
IOptions <ActiveDirectoryOptions> adOptions
) : base(commonDiLogic)
{
this.tensorBoardContainerRepository = tensorBoardContainerRepository;
this.userRepository = userRepository;
this.nodeRepository = nodeRepository;
this.clusterManagementService = clusterManagementService;
this.loginLogic = loginLogic;
this.gitLogic = gitLogic;
this.registryLogic = registryLogic;
this.versionLogic = versionLogic;
this.unitOfWork = unitOfWork;
this.containerOptions = containerOptions.Value;
this.adOptions = adOptions.Value;
}
/// <summary>
/// コンストラクタ
/// </summary>
public InferenceController(
ITrainingHistoryRepository trainingHistoryRepository,
IInferenceHistoryRepository inferenceHistoryRepository,
IDataSetRepository dataSetRepository,
ITenantRepository tenantRepository,
INodeRepository nodeRepository,
IDataSetLogic dataSetLogic,
IInferenceLogic inferenceLogic,
IStorageLogic storageLogic,
IGitLogic gitLogic,
IClusterManagementLogic clusterManagementLogic,
IUnitOfWork unitOfWork,
IHttpContextAccessor accessor) : base(accessor)
{
this.trainingHistoryRepository = trainingHistoryRepository;
this.inferenceHistoryRepository = inferenceHistoryRepository;
this.dataSetRepository = dataSetRepository;
this.tenantRepository = tenantRepository;
this.nodeRepository = nodeRepository;
this.dataSetLogic = dataSetLogic;
this.inferenceLogic = inferenceLogic;
this.storageLogic = storageLogic;
this.gitLogic = gitLogic;
this.clusterManagementLogic = clusterManagementLogic;
this.unitOfWork = unitOfWork;
}
/// <summary>
/// コンストラクタ
/// </summary>
public TrainingController(
ITrainingHistoryRepository trainingHistoryRepository,
IInferenceHistoryRepository inferenceHistoryRepository,
ITensorBoardContainerRepository tensorBoardContainerRepository,
IDataSetRepository dataSetRepository,
ITagRepository tagRepository,
ITenantRepository tenantRepository,
INodeRepository nodeRepository,
ITagLogic tagLogic,
ITrainingLogic trainingLogic,
IStorageLogic storageLogic,
IGitLogic gitLogic,
IClusterManagementLogic clusterManagementLogic,
IOptions <ContainerManageOptions> containerOptions,
IUnitOfWork unitOfWork,
IHttpContextAccessor accessor) : base(accessor)
{
this.trainingHistoryRepository = trainingHistoryRepository;
this.inferenceHistoryRepository = inferenceHistoryRepository;
this.tensorBoardContainerRepository = tensorBoardContainerRepository;
this.dataSetRepository = dataSetRepository;
this.tagRepository = tagRepository;
this.tenantRepository = tenantRepository;
this.nodeRepository = nodeRepository;
this.tagLogic = tagLogic;
this.trainingLogic = trainingLogic;
this.storageLogic = storageLogic;
this.gitLogic = gitLogic;
this.clusterManagementLogic = clusterManagementLogic;
this.containerOptions = containerOptions.Value;
this.unitOfWork = unitOfWork;
}
public NodeDeleter(ITmProcessConfig config, string nodeId)
: base(config)
{
this._nodeId = nodeId;
this._nodeRepository = base.ResolveDependency<INodeRepository>();
}
public NodeProvider(
INodeRepository nodeRepository,
INodeRelationRepository relationRepository)
{
_nodeRepository = nodeRepository;
_relationRepository = relationRepository;
}
/// <summary>
/// コンストラクタで各 DI オブジェクトを引数で受け取ります。
/// </summary>
public SyncClusterFromDBTimer(
ITenantRepository tenantRepository,
IRegistryRepository registryRepository,
INodeRepository nodeRepository,
IUnitOfWork unitOfWork,
IClusterManagementService clusterManagementService,
GitLabRegistryService gitLabRegistryService,
DockerHubRegistryService dockerHubRegistryService,
PrivateDockerRegistryService privateDockerRegistryService,
NvidiaGPUCloudRegistryService nvidiaGPUCloudRegistryService,
IClusterManagementLogic clusterManagementLogic,
IStorageLogic storageLogic,
IOptions <ContainerManageOptions> containerManageOptions,
IOptions <SyncClusterFromDBOptions> SyncClusterFromDBOptions,
ILogger <SyncClusterFromDBTimer> logger
) : base(logger, SyncClusterFromDBOptions.Value)
{
// 各 DI オブジェクトの設定
this.tenantRepository = tenantRepository;
this.registryRepository = registryRepository;
this.nodeRepository = nodeRepository;
this.unitOfWork = unitOfWork;
this.clusterManagementService = clusterManagementService;
this.gitLabRegistryService = gitLabRegistryService;
this.dockerHubRegistryService = dockerHubRegistryService;
this.privateDockerRegistryService = privateDockerRegistryService;
this.nvidiaGPUCloudRegistryService = nvidiaGPUCloudRegistryService;
this.clusterManagementLogic = clusterManagementLogic;
this.storageLogic = storageLogic;
this.containerManageOptions = containerManageOptions.Value;
}
public RequestHandler(INodeRepository nodeRepository, IDataRouteRepository routeRepository, ILogger logger)
{
_nodeRepository = nodeRepository;
_routeRepository = routeRepository;
_logger = logger;
_logger?.Debug("Request Handler Instantiated.");
}
public IActionResult GetPartitionsForAdmin([FromServices] INodeRepository nodeRepository)
{
//パーティション情報はDBから取得する。クラスタ側との同期は行わないので、必要なら別のAPIを呼ぶ仕様。
var nodes = nodeRepository.GetAll();
var partitions = nodes.Select(n => n.Partition).Distinct().Where(p => string.IsNullOrEmpty(p) == false).OrderBy(e => e); //並び替えして返却
return(JsonOK(partitions));
}
private static StatRegistry CreateSut(
NodeCollection <IStat> nodeCollection = null,
INodeRepository nodeRepository = null)
{
return(new StatRegistry(nodeCollection ?? CreateNodeCollection())
{
NodeRepository = nodeRepository
});
}
/// <summary>
/// Sets the current node repository implementation
/// </summary>
/// <param name="repository"></param>
/// <returns></returns>
public static INodeRepository SetCurrent(INodeRepository repository)
{
lock (SyncRoot)
{
var result = Current;
Current = repository;
return(result);
}
}
public CanvaViewModel(INodeRepository nodeRepository, IEventAggregator eventAggregator, NodeDetailsViewModel nodeDetailsViewModel)
{
_eventAggregator = eventAggregator;
_nodeDetailsViewModel = nodeDetailsViewModel;
_nodeRepository = nodeRepository;
_eventAggregator.Subscribe(this);
path = new List <LineModel>();
Draw();
}
public PerformanceController(INodeMonitorRepository nodemonitorRepostory, INodeRepository noderepostory, INodePerformanceRepository nodeperformanceRepostory, IPerformanceRepository rep, ITaskRepository taskrepostory, INodeRepository nodeRep, IUserRepository userRep)
: base(nodeRep, userRep)
{
performancerepository = rep;
taskrep = taskrepostory;
nodeperformanceRep = nodeperformanceRepostory;
noderep = noderepository;
nodemonitorRep = nodemonitorRepostory;
}
public static GeneralPurposeTreeNode <T> CreateANode <T>(INodeRepository <T> repo, long rootId,
string name = "Deneme", long?parentId = null)
{
GeneralPurposeTreeNode <T> insertedNode;
long idBeforeInserted;
CreateANode <T>(repo, out insertedNode, out idBeforeInserted, rootId, name, parentId);
return(insertedNode);
}
public TreeTests()
{
server = "mongodb://localhost";
databaseName = "Builders_Andre_Test";
collectionName = "Nodes";
nodeRepository = new NodeRepository(server, databaseName, collectionName);
binaryTree = new BinaryTreeService(nodeRepository);
}
/// <summary>
/// Sets the current node repository implementation
/// </summary>
/// <param name="repository"></param>
/// <returns></returns>
public static INodeRepository SetCurrent(INodeRepository repository)
{
lock (SyncRoot)
{
var result = Current;
Current = repository;
return result;
}
}
/// <summary>
/// Initializes a new instance of the <see cref="ShardService"/> class.
/// </summary>
/// <param name="nodeRepository">Concrete Node repository</param>
/// <param name="hashingFunction">Concrete Hashsing function</param>
/// <param name="vNodes">Number of virtual nodes - default = 10</param>
public ShardService(INodeRepository nodeRepository, IHashing hashingFunction, int vNodes = 10)
{
this.nodeRepository = nodeRepository;
var nodes = nodeRepository.GetAllNode();
if (nodes == null || nodes.Count == 0) throw new Exception("No available node, check your connection string or database");
ClusterManager = new ClusterManager(nodes, hashingFunction, vNodes);
}
public NodeCreator(ITmProcessConfig config, string nodeName, string ip, int port, string remark)
: base(config)
{
this._nodeName = nodeName;
this._ip = ip;
this._port = port;
this._remark = remark;
this._nodeRepository = base.ResolveDependency<INodeRepository>();
}
public AccountController(INodeRepository nodeRepository,
IAccessKeyRepository accessKeyRepository,
IUserRepository userKeyRepository,
IUserAccountRepository userAccountKeyRepository)
{
_nodeRepository = nodeRepository;
_accessKeyRepository = accessKeyRepository;
_userKeyRepository = userKeyRepository;
_userAccountKeyRepository = userAccountKeyRepository;
}
public UnitOfWork(DataDbContext dataDbContext, INodeRepository nodeRepository,
IUserRepository userRepository,
IFileVersionRepository fileVersionRepository, IRemovedNodeRepository removedNodeRepository)
{
DataDbContext = dataDbContext;
NodeRepository = nodeRepository;
UserRepository = userRepository;
FileVersionRepository = fileVersionRepository;
RemovedNodeRepository = removedNodeRepository;
}
public NodeController(
INodeRepository nodeRepository,
IUnitOfWork unitOfWork,
IClusterManagementLogic clusterManagementLogic,
IHttpContextAccessor accessor) : base(accessor)
{
this.nodeRepository = nodeRepository;
this.unitOfWork = unitOfWork;
this.clusterManagementLogic = clusterManagementLogic;
}
public NodeService(
INodeRepository nodeRepository,
IConfiguration configuration,
UserManager <ApplicationUser> userManager)
{
_nodeRepository = nodeRepository;
_contentAppSettings = new ContentAppSettings();
configuration.Bind(nameof(ContentAppSettings), _contentAppSettings);
_userManager = userManager;
}
public Calculator(
ISuspendableEvents suspender, IModifierCollection modifierCollection,
ICalculationGraphPruner graphPruner, INodeRepository nodeRepository,
INodeCollection <IStat> explicitlyRegisteredStats)
{
_suspender = suspender;
_modifierCollection = modifierCollection;
_graphPruner = graphPruner;
NodeRepository = nodeRepository;
ExplicitlyRegisteredStats = explicitlyRegisteredStats;
}
public Calculator(
EventBuffer eventBuffer, IModifierCollection modifierCollection,
ICalculationGraphPruner graphPruner, INodeRepository nodeRepository,
INodeCollection <IStat> explicitlyRegisteredStats)
{
_eventBuffer = eventBuffer;
_modifierCollection = modifierCollection;
_graphPruner = graphPruner;
NodeRepository = nodeRepository;
ExplicitlyRegisteredStats = explicitlyRegisteredStats;
}
public static void CreateANode <T>(INodeRepository <T> repo, out GeneralPurposeTreeNode <T> node, out long createdId,
long rootId, string name = "Deneme", long?parentId = null)
{
BindRepoTypeToDb <INodeRepository <T> >();
//node = new GeneralPurposeTreeNode<T> { Name = name, RootId = rootId, ParentId = parentId };
node = Kernel.Get <GeneralPurposeTreeNode <T> >();
node.RootId = rootId;
node.Name = name;
node.ParentId = parentId;
createdId = node.Id;
repo.InsertNode(node);
}
/// <summary>
/// Initializes a new instance of the <see cref="ShardService"/> class.
/// </summary>
/// <param name="nodeRepository">Concrete Node repository</param>
/// <param name="hashingFunction">Concrete Hashsing function</param>
/// <param name="vNodes">Number of virtual nodes - default = 10</param>
public ShardService(INodeRepository nodeRepository, IHashing hashingFunction, int vNodes = 10)
{
this.nodeRepository = nodeRepository;
var nodes = nodeRepository.GetAllNode();
if (nodes == null || nodes.Count == 0)
{
throw new Exception("No available node, check your connection string or database");
}
ClusterManager = new ClusterManager(nodes, hashingFunction, vNodes);
}
public NodeController(
INodeRepository nodeRepository,
IUnitOfWork unitOfWork,
IClusterManagementLogic clusterManagementLogic,
IOptions <ContainerManageOptions> containerManageOptions,
IHttpContextAccessor accessor) : base(accessor)
{
this.nodeRepository = nodeRepository;
this.unitOfWork = unitOfWork;
this.clusterManagementLogic = clusterManagementLogic;
this.containerManageOptions = containerManageOptions.Value;
}
public SampleContractController(IContractRepository contractRepository,
INodeRepository nodeRepository,
IAccessKeyRepository accessKeyRepository,
IUserRepository userRepository,
IUserAccountRepository userAccountRepository)
{
_contractRepository = contractRepository;
_nodeRepository = nodeRepository;
_accessKeyRepository = accessKeyRepository;
_userRepository = userRepository;
_userAccountRepository = userAccountRepository;
}
public async Task <IActionResult> GetResourceByTenant([FromServices] INodeRepository nodeRepository)
{
var nodes = nodeRepository.GetAll().OrderBy(n => n.Name);
var result = tenantRepository.GetAllTenants().OrderBy(t => t.DisplayName).ToDictionary(t => t.Name, t => new TenantResourceOutputModel(t));
var response = await clusterManagementLogic.GetAllContainerDetailsInfosAsync();
if (response.IsSuccess)
{
foreach (var container in response.Value)
{
//nodeInfoから必要な情報を取って、結果に含める
var nodeInfo = nodes.FirstOrDefault(n => n.Name == container.NodeName);
if (nodeInfo == null)
{
//登録ノードに所属していないコンテナは無視
continue;
}
if (result.ContainsKey(container.TenantName))
{
//テナント単位で集計する場合、テナントIDは自明なので、CreateContainerDetailsOutputModel()は使わない
result[container.TenantName].Add(new ContainerDetailsOutputModel(container)
{
CreatedBy = userRepository.GetUserName(container.CreatedBy)
});
}
else
{
//正体不明のテナントに紐づいたコンテナ
var unknownModel = new TenantResourceOutputModel(container.TenantName, containerManageOptions);
unknownModel.Add(new ContainerDetailsOutputModel(container)
{
CreatedBy = userRepository.GetUserName(container.CreatedBy)
});
result.Add(container.TenantName, unknownModel);
}
}
foreach (var tenant in result.Values)
{
// ノード名の昇順に並び替える
tenant.ContainerResourceList = tenant.ContainerResourceList.OrderBy(c => c.NodeName).ToList();
}
return(JsonOK(result.Values));
}
else
{
return(JsonError(HttpStatusCode.ServiceUnavailable, string.Join("\n", "Fetching container resource is failed.", response.Error)));
}
}
public void PreCompile(INodeRepository repository, IGraphData diagramData)
{
}
public void PostCompile(INodeRepository repository, IGraphData diagramData)
{
EditorApplication.ExecuteMenuItem("Visual Studio Tools/Generate Project Files");
}
public NodeManager(INodeRepository nodeRepository)
{
_nodeRepository = nodeRepository;
LocalizationManager = NullLocalizationManager.Instance;
}
public NodeAppService(NodeManager nodeManager, INodeRepository nodeRepository)
{
_nodeManager = nodeManager;
_nodeRepository = nodeRepository;
}
public NodesController(INodeRepository repo, IProjectService service)
{
_repo = repo;
_service = service;
}
public NodeService(INodeRepository nodeRepository)
{
this.nodeRepository = nodeRepository;
}
