/// <summary> /// Возвращает набор идентификаторов версий файлов с удаленного узла. /// </summary> /// <param name="remoteNode">Удаленный узел хранилища.</param> /// <param name="requestStorageID">Идентификатор узла, запрашиваюшего информацию (текущий узел)</param> /// <param name="folderUrl">Адрес папки.</param> /// <param name="from">Дата, с которой необходимо забрать изменения.</param> /// <returns></returns>/// <summary> public Tuple <Guid, Guid>[] GetReplicationFiles(IStorageNode remoteNode, Guid requestStorageID, string folderUrl, DateTime @from) { return (this.MakeRequest( x => x.GetReplicationFiles(this.CurrentNode.UniqueID, folderUrl, @from), remoteNode.Host)); }
/// <summary> /// Обмен схем репликации текущего узла с узлом storageHost. /// </summary> /// <param name="remoteNode">Удаленный узел хранилища.</param> /// <param name="currentReplicationSchema">Схема репликации текущего узла.</param> /// <returns></returns> public IReplicationSchema ExchangeSchema(IStorageNode remoteNode, IReplicationSchema currentReplicationSchema) { if (remoteNode == null) { throw new ArgumentNullException("remoteNode"); } if (currentReplicationSchema == null) { throw new ArgumentNullException("currentReplicationSchema"); } return(this.MakeRequest(x => { //схема репликации сети, известная текущему узлу WcfReplicationSchema typedCurrentReplicationSchema = new WcfReplicationSchema(currentReplicationSchema); WcfReplicationSchemaMessage exchangeMessage = new WcfReplicationSchemaMessage(typedCurrentReplicationSchema); //посылаем текущую схему узлу, к которому обращаемся //и получаем его схему с узла назначения WcfReplicationSchemaMessage remoteSchemaMessage = x.ExchangeSchema(exchangeMessage); return new WcfReplicationSchema(remoteSchemaMessage); }, remoteNode.Host)); }
/// <summary> /// Возвращает версию файла для репликации. /// </summary> /// <param name="remoteNode">Удаленный узел хранилища.</param> /// <param name="folderUrl">Папка файла.</param> /// <param name="fileUniqueID">Идентификатор файла.</param> /// <param name="fileVersionUniqueID">Идентификатор версии.</param> /// <returns></returns> public IRemoteFile GetReplicationFile(IStorageNode remoteNode, string folderUrl, Guid fileUniqueID, Guid fileVersionUniqueID) { if (remoteNode == null) { throw new ArgumentNullException("remoteNode"); } if (string.IsNullOrEmpty(folderUrl)) { throw new ArgumentNullException("folderUrl"); } WcfRemoteFile remoteFile = null; try { ChannelFactory <IStorageReplicationService> channelFactory = this.CreateServiceChannel(remoteNode.Host); using (channelFactory) { IStorageReplicationService client = channelFactory.CreateChannel(); WcfRemoteFileInfo fileInfo = WcfRemoteFileInfo.FromRemoteFileInfo(folderUrl, fileUniqueID, fileVersionUniqueID); remoteFile = client.GetReplicationFile(fileInfo); } } catch (Exception ex) { this.Logger.WriteMessage(ex.ToString(), LogLevel.Error); } return(remoteFile); }
private void ObserveWorker(object state) { if (state == null) { throw new ArgumentNullException("state"); } string host = state.ToString(); bool nodeAdded = false; while (!nodeAdded) { try { IStorageNode node = this.ReplicationAdapter.Transport.GetStorageInfo(host); if (node != null) { bool justCreated; this.EnsureNode(node.UniqueID, node.Host, out justCreated); //узел добавлен, можно отпустит поток nodeAdded = true; } } catch (Exception ex) { this.Engine.Logger.WriteMessage(ex.ToString()); } finally { Thread.Sleep(Timeouts.Observe); } } }
/// <summary>剪切待办信息</summary> /// <param name="applicationId">所属应用标识</param> /// <param name="fromReceiverId">待办来源接收者标识</param> /// <param name="toReceiverId">待办目标接收者标识</param> /// <param name="beginDate">复制待办的开始时间</param> /// <param name="endDate">复制待办结束时间</param> /// <returns></returns> public int Cut(string applicationId, string fromReceiverId, string toReceiverId, DateTime beginDate, DateTime endDate) { IStorageNode storageNode = storageStrategy.GetStorageNode("Query", toReceiverId); string whereClause = string.Format(" ApplicationId = ##{0}## AND Status = 0 AND CreateDate BETWEEN ##{0}## AND ##{1}## ", applicationId, beginDate, endDate); if (string.IsNullOrEmpty(applicationId)) { whereClause = string.Format(" Status = 0 AND CreateDate BETWEEN ##{0}## AND ##{1}## ", beginDate, endDate); } IList <TaskWorkItemInfo> list = this.FindAllByReceiverId(fromReceiverId, whereClause); foreach (TaskWorkItemInfo item in list) { Dictionary <string, object> args = new Dictionary <string, object>(); args.Add("Id", item.Id); args.Add("FromReceiverId", fromReceiverId); args.Add("ToReceiverId", toReceiverId); args.Add("Status", item.Status); args.Add("IsRead", 0); args.Add("FinishTime", new DateTime(2000, 1, 1)); this.ibatisMappers[storageNode.Name].Insert(StringHelper.ToProcedurePrefix(string.Format("{0}_Cut", this.tableName)), args); } return(0); }
private TestSuite(string testEnginePath, TestSuiteInstallation testSuiteInstallation, IStorageNode storageRoot) { TestEnginePath = testEnginePath; Id = testSuiteInstallation.Id; Name = testSuiteInstallation.Name; Description = testSuiteInstallation.Description; Removed = testSuiteInstallation.Removed; InstallMethod = testSuiteInstallation.InstallMethod; Version = testSuiteInstallation.Version; StorageRoot = storageRoot; // check if Plugin/config.xml can be found in TestSuite, if not then throw a new exception. string configXmlPath = Path.Combine(StorageRoot.GetNode(TestSuiteConsts.PluginFolderName).AbsolutePath, TestSuiteConsts.PluginConfigXml); if (!File.Exists(configXmlPath)) { throw new Exception($"TestSuite requires plugin xml:{configXmlPath}!"); } this.TestSuiteConfigFilePath = configXmlPath; }
public ReplicationFolder(StorageEngine storage, Folder folder, IStorageNode node, IReplicationFolderMetadata metadata) { if (storage == null) { throw new ArgumentNullException("storage"); } if (folder == null) { throw new ArgumentNullException("folder"); } if (node == null) { throw new ArgumentNullException("node"); } if (metadata == null) { throw new ArgumentNullException("metadata"); } this.TypedStorage = storage; this.TypedFolder = folder; this.Metadata = metadata; this.SourceStorage = node; }
/// <summary>转储所有记录信息</summary> /// <returns>返回一个<see cref="AccountCacheInfo"/>列表</returns> public IList <AccountCacheInfo> Dump() { IStorageNode storageNode = storageStrategy.GetStorageNode("Query"); Dictionary <string, object> args = new Dictionary <string, object>(); return(this.ibatisMappers[storageNode.Name].QueryForList <AccountCacheInfo>(StringHelper.ToProcedurePrefix(string.Format("{0}_Dump", tableName)), args)); }
public WcfStorageInfo(IStorageNode node) { if (node == null) { throw new ArgumentNullException("node"); } this.Node = node; }
/// <summary>设置任务完成</summary> /// <param name="receiverId">接收者</param> public void SetFinished(string receiverId) { IStorageNode storageNode = storageStrategy.GetStorageNode("Node", receiverId); Dictionary <string, object> args = new Dictionary <string, object>(); args.Add("WhereClause", string.Format(" ReceiverId = '{0}' ", receiverId)); this.ibatisMappers[storageNode.Name].Update(StringHelper.ToProcedurePrefix(string.Format("{0}_SetFinished", this.tableName)), args); }
private static string GetTestSuiteVersion(IStorageNode testSuiteInstallNode) { var binNode = testSuiteInstallNode.GetNode(TestSuiteConsts.Bin); using var versionFile = binNode.ReadFile(TestSuiteConsts.VersionFile); using var rs = new StreamReader(versionFile); var version = rs.ReadLine(); return(version); }
/// <summary>获取任务标签列表</summary> /// <param name="key">匹配标签的关键字, 空值则全部匹配</param> public IList <string> GetTaskTags(string key) { IStorageNode storageNode = storageStrategy.GetStorageNode("Query"); Dictionary <string, object> args = new Dictionary <string, object>(); args.Add("WhereClause", string.IsNullOrEmpty(key) ? string.Empty : string.Format(" Category LIKE '%{0}%' ", StringHelper.ToSafeSQL(key))); return(this.ibatisMappers[storageNode.Name].QueryForList <string>(StringHelper.ToProcedurePrefix(string.Format("{0}_GetTaskTags", this.tableName)), args)); }
public ReadTransaction(IStorageNode Node, long MinSequenceNumber, Action<long> UpdateSequenceNumber) { node = Node; id = Node.BeginTransaction() .Then(n => { if (n > MinSequenceNumber) UpdateSequenceNumber(n); return Math.Max(n, MinSequenceNumber); }); }
/// <summary>转储所有记录信息</summary> /// <param name="accountCacheValue">帐号缓存的值</param> /// <returns>返回一个<see cref="AccountCacheInfo"/>列表</returns> public IList <AccountCacheInfo> Dump(string accountCacheValue) { IStorageNode storageNode = storageStrategy.GetStorageNode("Query"); Dictionary <string, object> args = new Dictionary <string, object>(); args.Add("WhereClause", string.Format(" AccountCacheValue = '{0}' ", StringHelper.ToSafeSQL(accountCacheValue))); return(this.ibatisMappers[storageNode.Name].QueryForList <AccountCacheInfo>(StringHelper.ToProcedurePrefix(string.Format("{0}_Dump", tableName)), args)); }
/// <summary>查找某条记录</summary> /// <param name="accountCacheValue">帐号缓存的值</param> /// <returns>返回一个实例<see cref="AccountCacheInfo"/>的详细信息</returns> public AccountCacheInfo FindByAccountCacheValue(string accountCacheValue) { IStorageNode storageNode = storageStrategy.GetStorageNode("Query"); Dictionary <string, object> args = new Dictionary <string, object>(); args.Add("AccountCacheValue", StringHelper.ToSafeSQL(accountCacheValue, true)); return(this.ibatisMappers[storageNode.Name].QueryForObject <AccountCacheInfo>(StringHelper.ToProcedurePrefix(string.Format("{0}_FindByAccountCacheValue", tableName)), args)); }
/// <summary> /// Создает клиента сервиса репликации. /// </summary> /// <param name="storageNode">Целевой узел файлового хранилища.</param> /// <returns></returns> private ChannelFactory <IStorageReplicationService> CreateServiceChannel(IStorageNode storageNode) { if (storageNode == null) { throw new ArgumentNullException("storageNode"); } ChannelFactory <IStorageReplicationService> channel = this.CreateServiceChannel(storageNode.Host); return(channel); }
/// <summary>查询某条记录</summary> /// <param name="taskId">任务标识</param> /// <param name="receiverId">接收人标识</param> /// <returns>返回一个 TaskWorkReceiverInfo 实例的详细信息</returns> public TaskWorkItemInfo FindOne(string taskId, string receiverId) { IStorageNode storageNode = storageStrategy.GetStorageNode("Node", receiverId); Dictionary <string, object> args = new Dictionary <string, object>(); args.Add("TaskId", taskId); args.Add("ReceiverId", receiverId); return(this.ibatisMappers[storageNode.Name].QueryForObject <TaskWorkItemInfo>(StringHelper.ToProcedurePrefix(string.Format("{0}_FindOne", this.tableName)), args)); }
/// <summary>清理过期时间之前的缓存记录</summary> /// <param name="expiryTime">过期时间</param> public int Clear(DateTime expiryTime) { IStorageNode storageNode = storageStrategy.GetStorageNode("Node"); Dictionary <string, object> args = new Dictionary <string, object>(); args.Add("WhereClause", string.Format(" ValidTo < '{0}' ", expiryTime.ToString("yyyy-MM-dd HH:mm:ss"))); this.ibatisMappers[storageNode.Name].Delete(StringHelper.ToProcedurePrefix(string.Format("{0}_Delete", tableName)), args); return(0); }
/// <summary>删除记录</summary> /// <param name="accountIdentity">帐号会话唯一标识</param> public int Delete(string accountIdentity) { IStorageNode storageNode = storageStrategy.GetStorageNode("Node", accountIdentity); Dictionary <string, object> args = new Dictionary <string, object>(); args.Add("WhereClause", string.Format(" AccountIdentity < '{0}' ", StringHelper.ToSafeSQL(accountIdentity, true))); this.ibatisMappers[storageNode.Name].Delete(StringHelper.ToProcedurePrefix(string.Format("{0}_Delete", tableName)), args); return(0); }
/// <summary>添加记录</summary> /// <param name="param">TaskWorkInfo 实例的详细信息</param> public void Insert(TaskWorkInfo param) { IList <TaskWorkItemInfo> list = param.GetTaskWorkItems(); // 接收者信息 foreach (TaskWorkItemInfo item in list) { IStorageNode storageNode = storageStrategy.GetStorageNode("Node", item.ReceiverId); this.ibatisMappers[storageNode.Name].Insert(StringHelper.ToProcedurePrefix(string.Format("{0}_Insert", this.tableName)), item); } }
/// <summary>强制设置任务状态</summary> /// <param name="taskId">任务标识</param> /// <param name="receiverId">接收者的用户名</param> /// <param name="status">状态</param> public void SetStatus(string taskId, string receiverId, int status) { IStorageNode storageNode = storageStrategy.GetStorageNode("Node", receiverId); Dictionary <string, object> args = new Dictionary <string, object>(); args.Add("Id", taskId); args.Add("ReceiverId", receiverId); args.Add("Status", status); this.ibatisMappers[storageNode.Name].Update(StringHelper.ToProcedurePrefix(string.Format("{0}_SetStatus", this.tableName)), args); }
// ------------------------------------------------------- // 添加 删除 修改 // ------------------------------------------------------- #region 函数:Save(IStorageNode param) /// <summary>保存记录</summary> /// <param name="param">实例<see cref="IStorageNode"/>详细信息</param> /// <returns>实例<see cref="IStorageNode"/>详细信息</returns> public IStorageNode Save(IStorageNode param) { if (!this.IsExist(param.Id)) { this.Insert(param); } else { this.Update(param); } return(param); }
// 6.代理类型 ProxyTypes public static void Main26(string[] args) { Encoding.RegisterProvider(CodePagesEncodingProvider.Instance); ProxyGenerator generator = new ProxyGenerator(); IStorageNode node = generator.CreateInterfaceProxyWithTargetInterface <IStorageNode>(new StorageNode("master"), new DualNodeInterceptor(new StorageNode("slave")), new CallingLogInterceptor()); node.Save($"{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss")}:message"); //应该调用master对象 node.IsDead = true; node.Save($"{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss")}:message"); //应该调用master对象 node.Save($"{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss")}:message"); //应该调用master对象 Console.Read(); }
public void Intercept(IInvocation invocation) { IStorageNode master = invocation.InvocationTarget as IStorageNode; if (master.IsDead) { IChangeProxyTarget cpt = invocation as IChangeProxyTarget; // 将补代理对象master更换为slave cpt.ChangeProxyTarget(_slave); // 测试中恢复master状态,以便看到随后调用仍然使用master这一效果 master.IsDead = false; } invocation.Proceed(); }
// ------------------------------------------------------- // 查询 // ------------------------------------------------------- #region 函数:FindOne(XmlDocument doc) /// <summary>获取详细信息</summary> /// <param name="doc">Xml 文档对象</param> /// <returns>返回操作结果</returns> public string FindOne(XmlDocument doc) { StringBuilder outString = new StringBuilder(); string id = XmlHelper.Fetch("id", doc); IStorageNode param = this.service.FindOne(id); outString.Append("{\"data\":" + AjaxUtil.Parse <IStorageNode>(param) + ","); outString.Append(MessageObject.Stringify("0", I18n.Strings["msg_query_success"], true) + "}"); return(outString.ToString()); }
/// <summary>检测记录是否存在</summary> /// <param name="accountCacheValue">帐号缓存值</param> public bool IsExistAccountCacheValue(string accountCacheValue) { if (string.IsNullOrEmpty(accountCacheValue)) { throw new Exception("帐号缓存值不能为空。"); } IStorageNode storageNode = storageStrategy.GetStorageNode("Query"); Dictionary <string, object> args = new Dictionary <string, object>(); args.Add("WhereClause", string.Format(" AccountCacheValue = '{0}' ", StringHelper.ToSafeSQL(accountCacheValue, true))); return(((int)this.ibatisMappers[storageNode.Name].QueryForObject(StringHelper.ToProcedurePrefix(string.Format("{0}_IsExist", tableName)), args) == 0) ? false : true); }
/// <summary>查询是否存在相关的记录</summary> /// <param name="taskId">任务标识</param> /// <param name="receiverId">接收者标识</param> /// <returns>布尔值</returns> public bool IsExist(string taskId, string receiverId) { if (string.IsNullOrEmpty(taskId) || string.IsNullOrEmpty(receiverId)) { throw new Exception("实例标识不能为空。"); } IStorageNode storageNode = storageStrategy.GetStorageNode("Node", receiverId); Dictionary <string, object> args = new Dictionary <string, object>(); args.Add("WhereClause", string.Format(" TaskId = '{0}' AND ReceiverId = '{1}' ", StringHelper.ToSafeSQL(taskId), StringHelper.ToSafeSQL(receiverId))); return((Convert.ToInt32(this.ibatisMappers[storageNode.Name].QueryForObject(StringHelper.ToProcedurePrefix(string.Format("{0}_IsExist", this.tableName)), args)) == 0) ? false : true); }
public ReplicationSchema(IStorageNode storage, List <ReplicationSchemaItem> strongSchemaItems, List <ReplicationSchemaItem> weakSchemaItems) { if (storage == null) { throw new ArgumentNullException("storage"); } this.Storage = storage; if (strongSchemaItems != null) { this.StrongItems = strongSchemaItems.ToArray(); } if (weakSchemaItems != null) { this.WeakItems = weakSchemaItems.ToArray(); } }
/// <summary>设置任务未完成</summary> /// <param name="receiverId">接收者</param> /// <param name="taskIds">任务编号,多个以逗号分开</param> public void SetUnfinished(string receiverId, string taskIds) { if (string.IsNullOrEmpty(taskIds)) { return; } IStorageNode storageNode = storageStrategy.GetStorageNode("Node", receiverId); Dictionary <string, object> args = new Dictionary <string, object>(); taskIds = "'" + StringHelper.ToSafeSQL(taskIds).Replace(",", "','") + "'"; args.Add("WhereClause", string.Format(" ReceiverId = '{0}' AND Id IN ({1}) ", receiverId, taskIds)); this.ibatisMappers[storageNode.Name].Update(StringHelper.ToProcedurePrefix(string.Format("{0}_SetUnfinished", this.tableName)), args); }
private Configuration(TestSuiteConfiguration testSuiteConfiguration, ITestSuite testSuite, IStorageNode storageRoot) { Id = testSuiteConfiguration.Id; TestSuite = testSuite; Name = testSuiteConfiguration.Name; Description = testSuiteConfiguration.Description; StorageRoot = storageRoot; var ptfConfigStorage = StorageRoot.GetNode(ConfigurationConsts.PtfConfig); PtfConfig = new PtfConfig(ptfConfigStorage.GetFiles().ToList()); LoadFeatureMappingFromXml(); }
/// <summary>查询所有相关记录</summary> /// <param name="receiverId">接收者帐号标识</param> /// <param name="whereClause">SQL 查询条件</param> /// <param name="length">条数</param> /// <returns>返回所有 TaskWorkItemInfo 实例的详细信息</returns> public IList <TaskWorkItemInfo> FindAllByReceiverId(string receiverId, string whereClause, int length) { IStorageNode storageNode = storageStrategy.GetStorageNode("Node", receiverId); Dictionary <string, object> args = new Dictionary <string, object>(); args.Add("Length", length); if (string.IsNullOrEmpty(whereClause)) { args.Add("WhereClause", string.Format(" ReceiverId = '{0}' ORDER BY CreateDate DESC ", StringHelper.ToSafeSQL(receiverId))); } else { args.Add("WhereClause", string.Format(" ReceiverId = '{0}' AND {1} ", StringHelper.ToSafeSQL(receiverId), StringHelper.ToSafeSQL(whereClause))); } return(this.ibatisMappers[storageNode.Name].QueryForList <TaskWorkItemInfo>(StringHelper.ToProcedurePrefix(string.Format("{0}_FindAll", this.tableName)), args)); }
public Client(IStorageNode Node) { node = Node; }
public StorageSlice(IStorageNode storageNode, long startTime, int timeStep) { this.storageNode = storageNode; StartTime = startTime; TimeStep = timeStep; }