public DesignDevice(string name) { base.Name = name; base.BatteryLevel = 50; base.PhoneNumber = "(012) 345-6789"; base.WinMoDeviceId = "ABCDEF123456"; base.Manufacturer = "Faux"; base.Description = "3000"; StorageInfo info = new StorageInfo { TotalBytes = 0x2710L, UsedStorageMusic = 500L, UsedStoragePictures = 0x5dcL, UsedStoragePodcasts = 300L, UsedStorageVideos = 500L, UsedStorageApps = 0x3e8L, UsedStorageSystem = 0x3e8L, FreeBytes = 0x1388L }; base.StorageDevices = new Dictionary<string, StorageInfo>(); base.StorageDevices["built-in"] = info; info = new StorageInfo { TotalBytes = 0x2710L, UsedStorageMusic = 500L, UsedStoragePictures = 0x5dcL, UsedStoragePodcasts = 300L, UsedStorageVideos = 500L, UsedStorageApps = 0x3e8L, UsedStorageSystem = 0x3e8L, FreeBytes = 0x1388L }; base.StorageDevices["sd card"] = info; }
/// <summary> /// 创建任务 /// </summary> public static void CreatTaskInfo(DispatchTaskInfo TaskInfo, bool IsUserStoreState) { try { IDbOperator dbOperator = CreateDbOperator.DbOperatorInstance(ConnectConfigTool.DBase); using (TransactionScope scope = new TransactionScope()) { Hashtable hs = new Hashtable(); hs["dispatchNo"] = TaskInfo.dispatchNo; hs["stationNo"] = TaskInfo.stationNo; hs["BuildTime"] = DateTime.Now.ToString("yyyyMMddHHmmss"); hs["TaskState"] = TaskInfo.TaskState; hs["CallLand"] = TaskInfo.CallLand; hs["CallID"] = TaskInfo.CallID; hs["taskType"] = TaskInfo.taskType; hs["GoodsInfo"] = TaskInfo.GoodsInfo; hs["OwerArea"] = TaskInfo.OwerArea; //保存任务主表 dbOperator.SetDatas("InsertTaskInfo", hs); //保存任务明细信息 foreach (DispatchTaskDetail detail in TaskInfo.TaskDetail) { hs["DetailID"] = detail.DetailID; hs["LandCode"] = detail.LandCode; hs["OperType"] = detail.OperType; hs["IsAllowExcute"] = detail.IsAllowExcute; hs["PassType"] = detail.PassType; hs["State"] = detail.State; hs["PutType"] = detail.PutType; hs["IsSensorStop"] = detail.IsSensorStop; hs["PassTye"] = detail.PassType; hs["IsNeedCallBack"] = detail.IsNeedCallBack; hs["IsCallGoods"] = detail.IsCallGoods; hs["StorageID"] = detail.StorageID; dbOperator.SetDatas("InsertTaskDetail", hs); //处理储位占用 if (IsUserStoreState) { StorageInfo CurrentTaskUseStore = CoreData.StorageList.FirstOrDefault(p => p.ID == detail.StorageID); if (CurrentTaskUseStore != null) { hs["storeState"] = CurrentTaskUseStore.StorageState; hs["LockState"] = 1; hs["ID"] = CurrentTaskUseStore.ID; dbOperator.SetDatas("UpdateStorageState", hs); CurrentTaskUseStore.LockState = 1; } } } scope.Complete(); } } catch (Exception ex) { throw ex; } }
/// <summary> /// Creates the StorageInfo for the thread when one isn't already present. /// </summary> private StorageInfo CreateStorageInfo() { // we do our own locking, tell hosts this is a bad time to interrupt us. Thread.BeginCriticalRegion(); StorageInfo[] curStorage = s_updating; try { int threadId = GetCurrentThreadId(); StorageInfo newInfo = new StorageInfo(Thread.CurrentThread); // set to updating while potentially resizing/mutating, then we'll // set back to the current value. while ((curStorage = Interlocked.Exchange(ref _stores, s_updating)) == s_updating) { // another thread is already updating... Thread.Sleep(0); } // check and make sure we have a space in the array for our value if (curStorage == null) { curStorage = new StorageInfo[threadId + 1]; } else if (curStorage.Length <= threadId) { StorageInfo[] newStorage = new StorageInfo[threadId + 1]; for (int i = 0; i < curStorage.Length; i++) { // leave out the threads that have exited if (curStorage[i] != null && curStorage[i].Thread.IsAlive) { newStorage[i] = curStorage[i]; } } curStorage = newStorage; } // create our StorageInfo in the array, the empty check ensures we're only here // when we need to create. Debug.Assert(curStorage[threadId] == null || curStorage[threadId].Thread != Thread.CurrentThread); return(curStorage[threadId] = newInfo); } finally { if (curStorage != s_updating) { // let others access the storage again Interlocked.Exchange(ref _stores, curStorage); } Thread.EndCriticalRegion(); } }
/// 更新数据 /// </summary> /// <param name="info">数据表实体</param> public static bool UpdateStorageInfo(StorageInfo info) { try { return(StorageDAL.UpdateStorageInfo(info)); } catch { throw; } }
/// 添加数据 /// </summary> /// <param name="info">数据表实体对象</param> public static bool AddStorage(StorageInfo info) { try { return(StorageDAL.AddStorage(info)); } catch { throw; } }
public virtual void TestRegistrationWithDifferentSoftwareVersionsDuringUpgrade() { Configuration conf = new HdfsConfiguration(); conf.Set(DFSConfigKeys.DfsDatanodeMinSupportedNamenodeVersionKey, "1.0.0"); MiniDFSCluster cluster = null; try { cluster = new MiniDFSCluster.Builder(conf).NumDataNodes(0).Build(); NamenodeProtocols rpcServer = cluster.GetNameNodeRpc(); long nnCTime = cluster.GetNamesystem().GetFSImage().GetStorage().GetCTime(); StorageInfo mockStorageInfo = Org.Mockito.Mockito.Mock <StorageInfo>(); Org.Mockito.Mockito.DoReturn(nnCTime).When(mockStorageInfo).GetCTime(); DatanodeRegistration mockDnReg = Org.Mockito.Mockito.Mock <DatanodeRegistration>(); Org.Mockito.Mockito.DoReturn(HdfsConstants.DatanodeLayoutVersion).When(mockDnReg) .GetVersion(); Org.Mockito.Mockito.DoReturn("fake-storage-id").When(mockDnReg).GetDatanodeUuid(); Org.Mockito.Mockito.DoReturn(mockStorageInfo).When(mockDnReg).GetStorageInfo(); // Should succeed when software versions are the same and CTimes are the // same. Org.Mockito.Mockito.DoReturn(VersionInfo.GetVersion()).When(mockDnReg).GetSoftwareVersion (); Org.Mockito.Mockito.DoReturn("127.0.0.1").When(mockDnReg).GetIpAddr(); Org.Mockito.Mockito.DoReturn(123).When(mockDnReg).GetXferPort(); rpcServer.RegisterDatanode(mockDnReg); // Should succeed when software versions are the same and CTimes are // different. Org.Mockito.Mockito.DoReturn(nnCTime + 1).When(mockStorageInfo).GetCTime(); rpcServer.RegisterDatanode(mockDnReg); // Should fail when software version of DN is different from NN and CTimes // are different. Org.Mockito.Mockito.DoReturn(VersionInfo.GetVersion() + ".1").When(mockDnReg).GetSoftwareVersion (); try { rpcServer.RegisterDatanode(mockDnReg); NUnit.Framework.Assert.Fail("Should not have been able to register DN with different software" + " versions and CTimes"); } catch (IncorrectVersionException ive) { GenericTestUtils.AssertExceptionContains("does not match CTime of NN", ive); Log.Info("Got expected exception", ive); } } finally { if (cluster != null) { cluster.Shutdown(); } } }
public StructuredStorageRoot(string fileName) { try { this._storageRoot = (StorageInfo)StructuredStorageRoot.InvokeStorageRootMethod(null, "Open", fileName, FileMode.Open, FileAccess.Read, FileShare.Read); } catch (Exception innerException) { throw new StructuredStorageException("Cannot get StructuredStorageRoot", innerException); } }
public virtual QuorumCall <AsyncLogger, Void> DoUpgrade(StorageInfo sInfo) { IDictionary <AsyncLogger, ListenableFuture <Void> > calls = Maps.NewHashMap(); foreach (AsyncLogger logger in loggers) { ListenableFuture <Void> future = logger.DoUpgrade(sInfo); calls[logger] = future; } return(QuorumCall.Create(calls)); }
/// <summary> /// Invokes StorageRoot. /// </summary> /// <param name="storageRoot"></param> /// <param name="methodName"></param> /// <param name="methodArgs"></param> /// <returns></returns> private static object InvokeStorageRoot(StorageInfo storageRoot, string methodName, params object[] methodArgs) { if (methodName == null) { throw new ArgumentNullException(nameof(methodName)); } var type = typeof(StorageInfo).Assembly.GetType("System.IO.Packaging.StorageRoot", true, false); return(type.InvokeMember(methodName, _flags, null, storageRoot, methodArgs)); }
public StructuredStorageRoot(Stream stream) { try { this._storageRoot = (StorageInfo)StructuredStorageRoot.InvokeStorageRootMethod(null, "CreateOnStream", stream); } catch (Exception innerException) { throw new StructuredStorageException("Cannot get StructuredStorageRoot", innerException); } }
public IHttpActionResult GetStorageInfo(int id) { StorageInfo storageInfo = db.StorageInfoes.Find(id); if (storageInfo == null) { return(NotFound()); } return(Ok(storageInfo)); }
public StorageInfo GetStorage() { StorageInfo storageInfo = new StorageInfo(); NSFileSystemAttributes values = NSFileManager.DefaultManager.GetFileSystemAttributes(Environment.GetFolderPath(Environment.SpecialFolder.Personal)); storageInfo.LocalStorage.TotalSpace = values.Size; storageInfo.LocalStorage.FreeSpace = values.FreeSize; storageInfo.LocalStorage.AvailableSpace = values.FreeSize; return(storageInfo); }
public NamenodeRegistration(string address, string httpAddress, StorageInfo storageInfo , HdfsServerConstants.NamenodeRole role) : base(storageInfo) { // RPC address of the node // HTTP address of the node // node role this.rpcAddress = address; this.httpAddress = httpAddress; this.role = role; }
public DateTime GetAttachmentDateTime(string attachedFileName) { if (Path.IsPathRooted(attachedFileName)) { attachedFileName = System.IO.Path.GetFileName(attachedFileName); } StorageInfo storageInfo = m_SourceStorage.GetStorageInfo(attachedFileName, StorageInfoFlags.LastModified); return(storageInfo.LastModified); }
public IHttpActionResult PostStorageInfo(StorageInfo storageInfo) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } db.StorageInfoes.Add(storageInfo); db.SaveChanges(); return(CreatedAtRoute("DefaultApi", new { id = storageInfo.StorageId }, storageInfo)); }
public void DelRecord(StorageInfo obj) { int rec = _records.FindIndex(x => obj.Equals(x.Storage)); if (rec >= 0) { Record rc = _records[rec]; rc.ReturnBookDate = DateTime.Now; _records.RemoveAt(rec); _archive.Add(rc); } }
public static SerializableStorageInfo GetSerializableStorageInfo(StorageInfo storageInfo) { SerializableStorageInfo serializableStorageInfo = new SerializableStorageInfo { CreationDate = storageInfo.CreationDate, UsedStorage = storageInfo.UsedStorage }; GetInnerFiles(serializableStorageInfo.Directories, storageInfo.Directories); return(serializableStorageInfo); }
public StorageInfo GetStorageInfoModelByName(string sName) { StringBuilder strSql = new StringBuilder(); strSql.Append(" select top 1 StorageID,sCode,sName,sManager,sTel,sAddress,sRemake,sAppendTime,StorageClassID,sState,"); strSql.Append(" (select tbStaffInfo.sName from tbStaffInfo where tbStaffInfo.StaffID = sManager) as Manager ,"); strSql.Append(" (select tbStorageClassInfo.sClassName from tbStorageClassInfo where tbStorageClassInfo.StorageClassID=tbStorageInfo.StorageClassID) as storageName from tbStorageInfo"); strSql.Append(" where sCode=@sCode "); SqlParameter[] parameters = { new SqlParameter("@sName", SqlDbType.VarChar, 50) }; parameters[0].Value = sName; StorageInfo model = new StorageInfo(); DataSet ds = DbHelper.ExecuteDataset(CommandType.Text, strSql.ToString(), parameters); if (ds.Tables[0].Rows.Count > 0) { if (ds.Tables[0].Rows[0]["StorageID"].ToString() != "") { model.StorageID = int.Parse(ds.Tables[0].Rows[0]["StorageID"].ToString()); } model.sCode = ds.Tables[0].Rows[0]["sCode"].ToString(); model.sName = ds.Tables[0].Rows[0]["sName"].ToString(); model.ManagerName = ds.Tables[0].Rows[0]["Manager"].ToString(); if (ds.Tables[0].Rows[0]["sManager"].ToString() != "") { model.sManager = int.Parse(ds.Tables[0].Rows[0]["sManager"].ToString()); } model.sTel = ds.Tables[0].Rows[0]["sTel"].ToString(); model.sAddress = ds.Tables[0].Rows[0]["sAddress"].ToString(); model.sRemake = ds.Tables[0].Rows[0]["sRemake"].ToString(); if (ds.Tables[0].Rows[0]["sAppendTime"].ToString() != "") { model.sAppendTime = DateTime.Parse(ds.Tables[0].Rows[0]["sAppendTime"].ToString()); } if (ds.Tables[0].Rows[0]["StorageClassID"].ToString() != "") { model.StorageClassID = int.Parse(ds.Tables[0].Rows[0]["StorageClassID"].ToString()); } model.StorageName = ds.Tables[0].Rows[0]["storageName"].ToString(); if (ds.Tables[0].Rows[0]["sState"].ToString() != "") { model.sState = int.Parse(ds.Tables[0].Rows[0]["sState"].ToString()); } return(model); } else { return(null); } }
/// <summary> /// 删除一个对象 /// </summary> /// <param name="GrainID">主键</param> /// <returns></returns> public static bool DeleteStorageInfo(StorageInfo info) { bool rst = false; string sqlStr = "DELETE FROM Storage WHERE GrainID=" + info.GrainID; int rows = DBManager.ExecuteUpdate(sqlStr); if (rows > 0) { rst = true; } return(rst); }
public OleStorageFile(Path oleStorageFilePath) { int checkResult = NativeMethods.StgIsStorageFile(oleStorageFilePath.FullPathString); if (checkResult != 0) { throw new ArgumentException("The specified file is not an OLE Structured Storage file."); } _oleStorageFilePath = oleStorageFilePath; _storageRoot = GetStorageRoot(_oleStorageFilePath); _isDisposed = false; }
private bool AreTargetSlotsBlocked(Item item, byte toSlot, StorageInfo toStorage, bool[,] usedSlots) { for (var i = toStorage.StartIndex; i < toStorage.EndIndex; i++) { if (this.IsTargetSlotBlocked(item, toSlot, toStorage, usedSlots)) { return(true); } } return(false); }
private StorageInfo GetStorageInfo(Player player, Storages storageType) { StorageInfo result; switch (storageType) { case Storages.Inventory: result = new StorageInfo { Rows = InventoryRows, StartIndex = EquippableSlotsCount, EndIndex = (byte)(EquippableSlotsCount + GetInventorySize(player)), Storage = player.Inventory }; break; case Storages.PersonalStore: result = new StorageInfo { Rows = StoreRows, StartIndex = FirstStoreItemSlotIndex, EndIndex = (byte)(FirstStoreItemSlotIndex + StoreSize), Storage = player.ShopStorage }; break; case Storages.Vault: result = new StorageInfo { Rows = WarehouseRows, EndIndex = WarehouseSize, Storage = player.Vault, StartIndex = 0 }; break; case Storages.Trade: case Storages.ChaosMachine: result = new StorageInfo { Storage = player.TemporaryStorage, Rows = TemporaryStorageRows, EndIndex = TemporaryStorageSize, StartIndex = 0 }; break; default: throw new NotImplementedException($"Moving to {storageType} is not implemented."); } return(result); }
private void FormMain_Load(object sender, EventArgs e) { try { _storage = StorageInfoLoader.Load(); ReloadInfo(); } catch (Exception exception) { MessageBox.Show(exception.Message, ErrorConstants.CRITICAL_ERROR, MessageBoxButtons.OK, MessageBoxIcon.Error); this.Close(); } }
/// <exception cref="System.IO.IOException"/> public virtual void DoUpgrade(string journalId, StorageInfo sInfo) { try { rpcProxy.DoUpgrade(NullController, ((QJournalProtocolProtos.DoUpgradeRequestProto )QJournalProtocolProtos.DoUpgradeRequestProto.NewBuilder().SetJid(ConvertJournalId (journalId)).SetSInfo(PBHelper.Convert(sInfo)).Build())); } catch (ServiceException e) { throw ProtobufHelper.GetRemoteException(e); } }
public virtual QuorumCall <AsyncLogger, bool> CanRollBack(StorageInfo storage, StorageInfo prevStorage, int targetLayoutVersion) { IDictionary <AsyncLogger, ListenableFuture <bool> > calls = Maps.NewHashMap(); foreach (AsyncLogger logger in loggers) { ListenableFuture <bool> future = logger.CanRollBack(storage, prevStorage, targetLayoutVersion ); calls[logger] = future; } return(QuorumCall.Create(calls)); }
// --- // TODO: Can't use `Serialization.Collections` utilities because can't // implement `INetSerializable` on `Item.Kind` or `Option<Item.Kind>`. // For now we'll just do it manually. private void SerializeData(NetDataWriter writer) { int count = data.Count; writer.Put(count); foreach (KeyValuePair <Item.Kind, StorageInfo> pair in data) { Item.Kind itemKind = pair.Key; StorageInfo storageInfo = pair.Value; writer.Put((int)pair.Key); storageInfo.Serialize(writer); } }
private void DeserializeData(NetDataReader reader) { int count = reader.GetInt(); data = new Dictionary <Item.Kind, StorageInfo>(count); for (int i = 0; i < count; i++) { var itemKind = (Item.Kind)reader.GetInt(); StorageInfo storageInfo = new StorageInfo(); storageInfo.Deserialize(reader); data.Add(itemKind, storageInfo); } }
public virtual void TestRegistrationWithDifferentSoftwareVersions() { Configuration conf = new HdfsConfiguration(); conf.Set(DFSConfigKeys.DfsDatanodeMinSupportedNamenodeVersionKey, "3.0.0"); conf.Set(DFSConfigKeys.DfsNamenodeMinSupportedDatanodeVersionKey, "3.0.0"); MiniDFSCluster cluster = null; try { cluster = new MiniDFSCluster.Builder(conf).NumDataNodes(0).Build(); NamenodeProtocols rpcServer = cluster.GetNameNodeRpc(); long nnCTime = cluster.GetNamesystem().GetFSImage().GetStorage().GetCTime(); StorageInfo mockStorageInfo = Org.Mockito.Mockito.Mock <StorageInfo>(); Org.Mockito.Mockito.DoReturn(nnCTime).When(mockStorageInfo).GetCTime(); DatanodeRegistration mockDnReg = Org.Mockito.Mockito.Mock <DatanodeRegistration>(); Org.Mockito.Mockito.DoReturn(HdfsConstants.DatanodeLayoutVersion).When(mockDnReg) .GetVersion(); Org.Mockito.Mockito.DoReturn("127.0.0.1").When(mockDnReg).GetIpAddr(); Org.Mockito.Mockito.DoReturn(123).When(mockDnReg).GetXferPort(); Org.Mockito.Mockito.DoReturn("fake-storage-id").When(mockDnReg).GetDatanodeUuid(); Org.Mockito.Mockito.DoReturn(mockStorageInfo).When(mockDnReg).GetStorageInfo(); // Should succeed when software versions are the same. Org.Mockito.Mockito.DoReturn("3.0.0").When(mockDnReg).GetSoftwareVersion(); rpcServer.RegisterDatanode(mockDnReg); // Should succeed when software version of DN is above minimum required by NN. Org.Mockito.Mockito.DoReturn("4.0.0").When(mockDnReg).GetSoftwareVersion(); rpcServer.RegisterDatanode(mockDnReg); // Should fail when software version of DN is below minimum required by NN. Org.Mockito.Mockito.DoReturn("2.0.0").When(mockDnReg).GetSoftwareVersion(); try { rpcServer.RegisterDatanode(mockDnReg); NUnit.Framework.Assert.Fail("Should not have been able to register DN with too-low version." ); } catch (IncorrectVersionException ive) { GenericTestUtils.AssertExceptionContains("The reported DataNode version is too low" , ive); Log.Info("Got expected exception", ive); } } finally { if (cluster != null) { cluster.Shutdown(); } } }
/// <summary> /// Gets the current value if its not == null or calls the provided function /// to create a new value. /// </summary> public T GetOrCreate(Func <T> func) { Assert.NotNull(func); StorageInfo si = GetStorageInfo(); T res = si.Value; if (res == null) { si.Value = res = func(); } return(res); }
public StructuredStorageRoot(Stream stream) { try { _storageRoot = (StorageInfo)InvokeStorageRootMethod( null, "CreateOnStream", stream); } catch (Exception ex) { throw new StructuredStorageException( "Cannot get StructuredStorageRoot", ex); } }
private void SetUsedSlots(StorageInfo toStorage, Item blockingItem, bool[,] usedSlots) { int columnIndex = (blockingItem.ItemSlot - toStorage.StartIndex) % RowSize; int rowIndex = (blockingItem.ItemSlot - toStorage.StartIndex) / RowSize; // Set all taken slots of this item to true for (int r = rowIndex; r < rowIndex + blockingItem.Definition.Height; r++) { for (int c = columnIndex; c < columnIndex + blockingItem.Definition.Width; c++) { usedSlots[r, c] = true; } } }
public static void Run() { while (Nagme.Globals.programRunning) { DriveInfo[] drives = DriveInfo.GetDrives (); List<StorageInfo> storeInfo = new List<StorageInfo>(); foreach (DriveInfo drive in drives) { if (drive.DriveType == DriveType.Fixed) { StorageInfo tmpStore = new StorageInfo(); System.Console.WriteLine ("Drive Root: " + drive.RootDirectory); System.Console.WriteLine ("Drive Size: " + drive.TotalSize); System.Console.WriteLine ("Free Space: " + drive.TotalFreeSpace); tmpStore.RootDirectory = drive.RootDirectory.ToString(); tmpStore.VolumeLabel = drive.VolumeLabel.ToString(); tmpStore.TotalSize = (int)(drive.TotalSize/1024/1024); tmpStore.TotalFreeSize = (int)(drive.TotalFreeSpace/1024/1024); storeInfo.Add(tmpStore); } } INagMe register = (INagMe)XmlRpcProxyGen.Create(typeof(INagMe)); register.Url = Nagme.Globals.xmlrpcAddress(); if(register.updateDriveInfo(storeInfo.ToArray(), Nagme.Globals.DeviceID(), Nagme.Globals.DevicePassword())){ Console.WriteLine("Updated Storage Info"); }else{ Console.WriteLine("Failed Storage General Info"); } Console.WriteLine(""); System.Threading.Thread.Sleep (60000); } }
private StorageInfo GetStorageDeviceInfo(IDevice device) { StorageInfo info; if ((device.StorageDevices == null) || (device.StorageDevices.Count < 1)) { info = new StorageInfo(); this.currentStorageArea = ""; this.OnPropertyChanged("CurrentStorageArea"); return info; } if ((this.CurrentStorageArea == null) || !device.StorageDevices.TryGetValue(this.CurrentStorageArea, out info)) { info = device.StorageDevices.FirstOrDefault<KeyValuePair<string, StorageInfo>>().Value; this.currentStorageArea = device.StorageDevices.FirstOrDefault<KeyValuePair<string, StorageInfo>>().Key; this.OnPropertyChanged("CurrentStorageArea"); } return info; }