public SubCopy(Int32 id) { subCopyID = id; count = 0; copyState = CopyState.UNOPEN; tblCopyDetail = TableManager.GetCopydetailByID(subCopyID); }
public override Expression CopyExpression(CopyState state) { return(new NewVertexAttrib(Source, state.GetType(_dt), VertexAttributeType.CopyNullable(state), VertexBuffer.CopyNullable(state), VertexBufferStride.CopyNullable(state), VertexBufferOffset.CopyNullable(state), OptionalIndexType.CopyNullable(state), OptionalIndexBuffer.CopyNullable(state))); }
private void SwitchState(CopyState cs) { copystate = cs; if (cs == CopyState.copying) { GetComponent <ShapeMenu>().StateSwitch(SelectionState.NOSELECTION); FormMenu.SetActive(false); MarkerBounds.SetActive(false); PastingModeSwitch.gameObject.SetActive(true); EnterCopyPasteMenu.interactable = true; FormPanel.GetComponent <Form>().FormSlider.GetComponent <FormSlider>().SwitchTextStatus("TAB/LMB/RMB/Q/I/ESC/DEL"); } else { HeightSlider.gameObject.SetActive(true); MarkerBounds.SetActive(true); FormPanel.GetComponent <Form>().FormSlider.GetComponent <FormSlider>().SwitchTextStatus("Shape forming"); if (cs == CopyState.empty) { PastingModeSwitch.gameObject.SetActive(false); RemoveCopyPoints(); CopyClipboard.Clear(); EnterCopyPasteMenu.interactable = false; } else if (cs == CopyState.non_empty) { PastingModeSwitch.gameObject.SetActive(false); RemoveCopyPoints(); } } }
void LoadCopy(Player p, string file) { string path = FindCopy(p.name, file); if (path == null) { Player.Message(p, "No such copy exists"); return; } using (FileStream fs = File.OpenRead(path)) using (GZipStream gs = new GZipStream(fs, CompressionMode.Decompress)) { CopyState state = new CopyState(0, 0, 0, 0, 0, 0, null, null); if (path.CaselessEnds(".cpb")) { state.LoadFrom(gs); } else { state.LoadFromOld(gs, fs); } p.CopyBuffer = state; } Player.Message(p, "Loaded copy as " + file); }
/// <summary> /// Creates an archived copy of the original package blob if it doesn't already exist. /// </summary> private void ArchiveOriginalPackageBlob(CloudBlockBlob originalPackageBlob, CloudBlockBlob latestPackageBlob) { // Copy the blob to backup only if it isn't already successfully copied if ((!originalPackageBlob.Exists()) || (originalPackageBlob.CopyState != null && originalPackageBlob.CopyState.Status != CopyStatus.Success)) { if (!WhatIf) { Log.Info("Backing up blob: {0} to {1}", latestPackageBlob.Name, originalPackageBlob.Name); originalPackageBlob.StartCopyFromBlob(latestPackageBlob); CopyState state = originalPackageBlob.CopyState; for (int i = 0; (state == null || state.Status == CopyStatus.Pending) && i < SleepTimes.Length; i++) { Log.Info("(sleeping for a copy completion)"); Thread.Sleep(SleepTimes[i]); originalPackageBlob.FetchAttributes(); // To get a refreshed CopyState //refresh state state = originalPackageBlob.CopyState; } if (state.Status != CopyStatus.Success) { string msg = $"Blob copy failed: CopyState={state.StatusDescription}"; Log.Error("(error) " + msg); throw new BlobBackupFailedException(msg); } } } }
/// <summary> /// Callback method to be called when the corresponding write operation completes. /// </summary> /// <param name="asyncResult">The result of the asynchronous operation.</param> private void FastCopyToCallback(IAsyncResult asyncResult) { if (asyncResult.CompletedSynchronously) { return; } StorageAsyncResult <NullType> result = (StorageAsyncResult <NullType>)asyncResult.AsyncState; result.UpdateCompletedSynchronously(asyncResult.CompletedSynchronously); CopyState copyState = (CopyState)result.OperationState; try { copyState.Destination.EndWrite(asyncResult); this.FastCopyToInternal(result); } catch (Exception e) { if (copyState.ExpiryTime.HasValue && DateTime.Now.CompareTo(copyState.ExpiryTime.Value) > 0) { result.OnComplete(new TimeoutException()); } else { result.OnComplete(e); } } }
public override void Use(Player p, string message, CommandData data) { if (message.Length == 0) { Help(p); return; } if (p.CurrentCopy == null) { p.Message("You haven't copied anything yet"); return; } CopyState cState = p.CurrentCopy; BlockDefinition[] defs = p.level.CustomBlockDefs; foreach (string arg in message.SplitSpaces()) { if (arg.CaselessEq("x")) { Flip.MirrorX(cState, defs); p.Message("Flipped copy across the X (east/west) axis."); } else if (arg.CaselessEq("y") || arg.CaselessEq("u")) { Flip.MirrorY(cState, defs); p.Message("Flipped copy across the Y (vertical) axis."); } else if (arg.CaselessEq("z")) { Flip.MirrorZ(cState, defs); p.Message("Flipped copy across the Z (north/south) axis."); } } }
private async Task GetCopyStateAsync() { Debug.Assert( this.state == State.GetCopyState, "GetCopyStateAsync called, but state isn't GetCopyState"); this.hasWork = false; this.StartCallbackHandler(); CopyState copyState = null; try { copyState = await this.FetchCopyStateAsync(); } catch (StorageException se) { if (null != se.RequestInformation && se.RequestInformation.HttpStatusCode == (int)HttpStatusCode.NotFound) { // The reason of 404 (Not Found) may be that the destination blob has not been created yet. this.RestartTimer(); } else { throw; } } this.HandleFetchCopyStateResult(copyState); }
void LoadCopy(Player p, string file) { string path = FindCopy(p.name, file); if (path == null) { p.Message("No such copy exists"); return; } using (FileStream fs = File.OpenRead(path)) using (GZipStream gs = new GZipStream(fs, CompressionMode.Decompress)) { CopyState state = new CopyState(0, 0, 0, 0, 0, 0); if (path.CaselessEnds(".cpb")) { state.LoadFrom(gs); } else { state.LoadFromOld(gs, fs); } state.CopySource = "file " + file; p.CurrentCopy = state; } p.Message("Loaded copy from " + file); }
public override Brush Construct(BrushArgs args) { CopyState cState = args.Player.CurrentCopy; if (cState == null) { args.Player.Message("You haven't copied anything yet."); return(null); } if (args.Message.Length == 0) { return(new SimplePasteBrush(cState)); } string[] parts = args.Message.SplitSpaces(); if (parts[0].CaselessEq("not")) { PasteNotBrush brush = new PasteNotBrush(cState); brush.Exclude = ReplaceBrushFactory.GetBlocks(args.Player, 1, parts.Length, parts); return(brush.Exclude == null ? null : brush); } else { PasteBrush brush = new PasteBrush(cState); brush.Include = ReplaceBrushFactory.GetBlocks(args.Player, 0, parts.Length, parts); return(brush.Include == null ? null : brush); } }
public override void Perform(Vec3U16[] marks, Player p, Level lvl, Brush brush) { Vec3U16 p1 = marks[0]; CopyState state = CopyState; bool pasteAir = state.PasteAir; // Adjust for the fact that paste origin may be outside the map. short offX = (short)p1.X, offY = (short)p1.Y, offZ = (short)p1.Z; for (int i = 0; i < state.Blocks.Length; i++) { ushort locX, locY, locZ; byte b = state.Blocks[i], extB = state.ExtBlocks[i]; state.GetCoords(i, out locX, out locY, out locZ); ushort x = (ushort)(locX + offX), y = (ushort)(locY + offY), z = (ushort)(locZ + offZ); byte type = lvl.GetTile(x, y, z), extType = 0; if (type == Block.custom_block) { extType = lvl.GetExtTile(x, y, z); } bool place = lvl.InBound(x, y, z) && (b != type || (b == Block.custom_block && extB != extType)); if ((b != Block.air || pasteAir) && place) { PlaceBlock(p, lvl, x, y, z, b, extB); } } }
void LoadCopy(Player p, string file) { string path = "extra/savecopy/" + p.name + "/" + file; bool existsNew = File.Exists(path + ".cpb"); bool existsOld = File.Exists(path + ".cpy"); if (!existsNew && !existsOld) { Player.SendMessage(p, "No such copy exists"); return; } path = existsNew ? path + ".cpb" : path + ".cpy"; using (FileStream fs = new FileStream(path, FileMode.Open)) using (GZipStream gs = new GZipStream(fs, CompressionMode.Decompress)) { CopyState state = new CopyState(0, 0, 0, 0, 0, 0, null, null); if (existsNew) { state.LoadFrom(gs); } else { state.LoadFromOld(gs, fs); } p.CopyBuffer = state; } Player.SendMessage(p, "Loaded copy as " + file); }
static void CopyCallback([NotNull] Player player, [NotNull] Vector3I[] marks, [NotNull] object tag) { int sx = Math.Min(marks[0].X, marks[1].X); int ex = Math.Max(marks[0].X, marks[1].X); int sy = Math.Min(marks[0].Y, marks[1].Y); int ey = Math.Max(marks[0].Y, marks[1].Y); int sz = Math.Min(marks[0].Z, marks[1].Z); int ez = Math.Max(marks[0].Z, marks[1].Z); BoundingBox bounds = new BoundingBox(sx, sy, sz, ex, ey, ez); int volume = bounds.Volume; if (!player.CanDraw(volume)) { player.MessageNow( "You are only allowed to run commands that affect up to {0} blocks. This one would affect {1} blocks.", player.Info.Rank.DrawLimit, volume); return; } // remember dimensions and orientation CopyState copyInfo = new CopyState(marks[0], marks[1]); Map map = player.WorldMap; World playerWorld = player.World; if (playerWorld == null) { PlayerOpException.ThrowNoWorld(player); } for (int x = sx; x <= ex; x++) { for (int y = sy; y <= ey; y++) { for (int z = sz; z <= ez; z++) { copyInfo.Blocks[x - sx, y - sy, z - sz] = map.GetBlock(x, y, z); } } } copyInfo.OriginWorld = playerWorld.Name; copyInfo.CopyTime = DateTime.UtcNow; player.SetCopyState(copyInfo); player.MessageNow("{0} blocks copied into slot #{1}, origin at {2} corner. You can now &H/Paste", volume, player.CopySlot + 1, copyInfo.OriginCorner); Logger.Log(LogType.UserActivity, "{0} copied {1} blocks from world {2} (between {3} and {4}).", player.Name, volume, playerWorld.Name, bounds.MinVertex, bounds.MaxVertex); }
public void UpdateState() { //update subcoyt first if (tblCopy.GetCopyTypebyIndex(0) == (int)CopyType.NORMAL) { foreach (SubCopy copy in subCopys) { if (copy.count > 0) { copy.copyState = CopyState.PASSED; } else { copy.copyState = CopyState.UNOPEN; } } } CopyState state = CopyState.UNOPEN; foreach (SubCopy copy in subCopys) { state = copy.copyState; if (state == CopyState.OPENED) { copyState = CopyState.OPENED; return; } } copyState = state; }
private String CopyStateText(CopyState state) { if (state == null) { return(String.Empty); } else { switch (state.Status) { case CopyStatus.Pending: return("Pending"); case CopyStatus.Success: return("Success"); case CopyStatus.Aborted: return("Aborted"); case CopyStatus.Failed: return("Failed"); case CopyStatus.Invalid: return("Invalid"); default: return("Other"); } } }
void SaveCopy(Player p, string file) { if (!Directory.Exists("extra/savecopy")) { Directory.CreateDirectory("extra/savecopy"); } if (!Directory.Exists("extra/savecopy/" + p.name)) { Directory.CreateDirectory("extra/savecopy/" + p.name); } if (Directory.GetFiles("extra/savecopy/" + p.name).Length > 15) { p.Message("You can only save a maxmium of 15 copies. /copy delete some."); return; } CopyState cState = p.CurrentCopy; if (cState == null) { p.Message("You haven't copied anything yet"); return; } string path = "extra/savecopy/" + p.name + "/" + file + ".cpb"; using (FileStream fs = File.Create(path)) using (GZipStream gs = new GZipStream(fs, CompressionMode.Compress)) { cState.SaveTo(gs); } p.Message("Saved copy as " + file); }
public override void Perform(Vec3U16[] marks, Player p, Level lvl, Brush brush) { Vec3U16 p1 = marks[0]; CopyState state = CopyState; bool pasteAir = state.PasteAir; ExtBlock[] include = Include, exclude = Exclude; // Adjust for the fact that paste origin may be outside the map. short offX = (short)p1.X, offY = (short)p1.Y, offZ = (short)p1.Z; for (int i = 0; i < state.Blocks.Length; i++) { ushort locX, locY, locZ; byte b = state.Blocks[i], extB = state.ExtBlocks[i]; state.GetCoords(i, out locX, out locY, out locZ); ushort x = (ushort)(locX + offX), y = (ushort)(locY + offY), z = (ushort)(locZ + offZ); byte type = lvl.GetTile(x, y, z), extType = 0; if (type == Block.custom_block) { extType = lvl.GetExtTile(x, y, z); } bool place = lvl.InBound(x, y, z) && (b != type || (b == Block.custom_block && extB != extType)); if (!place || (b == Block.air && !pasteAir)) { continue; } if (exclude != null) { for (int j = 0; j < exclude.Length; j++) { ExtBlock block = exclude[j]; if (b == block.Type && (b != Block.custom_block || extB == block.ExtType)) { place = false; break; } } if (!place) { continue; } PlaceBlock(p, lvl, x, y, z, b, extB); } if (include != null) { for (int j = 0; j < include.Length; j++) { ExtBlock block = include[j]; if (b == block.Type && (b != Block.custom_block || extB == block.ExtType)) { PlaceBlock(p, lvl, x, y, z, b, extB); break; } } } } }
public override void Use(Player p, string message, CommandData data) { if (message.Length == 0) { message = "y"; } if (p.CurrentCopy == null) { p.Message("You haven't copied anything yet"); return; } CopyState cState = p.CurrentCopy; string opt = message.ToLower(); BlockDefinition[] defs = p.level.CustomBlockDefs; // /Mirror used to be part of spin if (opt.CaselessStarts("mirror")) { p.Message("&T/Spin {0} &Sis deprecated. Use &T/Mirror &Sinstead", opt); return; } string[] args = opt.SplitSpaces(); char axis = 'Y'; int angle = 90; if (!Handle(ref axis, ref angle, args[0])) { Help(p); return; } if (args.Length > 1 && !Handle(ref axis, ref angle, args[1])) { Help(p); return; } CopyState newState = cState; if (angle == 0) { } else if (axis == 'X') { newState = Flip.RotateX(cState, angle, defs); } else if (axis == 'Y') { newState = Flip.RotateY(cState, angle, defs); } else if (axis == 'Z') { newState = Flip.RotateZ(cState, angle, defs); } newState.CopySource = cState.CopySource; newState.CopyTime = cState.CopyTime; p.CurrentCopy = newState; p.Message("Rotated copy {0} degrees around the {1} axis", angle, axis); }
public void SetCurrentCopy(CopyState state) { while (CurrentCopySlot >= CopySlots.Count) { CopySlots.Add(null); } CopySlots[CurrentCopySlot] = state; }
public override Statement CopyStatement(CopyState state) { return(new For(Source, OptionalInitializer.CopyNullable(state), OptionalCondition.CopyNullable(state), OptionalIncrement.CopyNullable(state), OptionalBody.CopyNullable(state))); }
public async Task refreshCopyJobAsync() { TableStorage <CopyJob> copyJobTableStorage = new TableStorage <CopyJob>(masterStorageAccount, "jobs"); TableStorage <CopyJob> copyCompleteJobTableStorage = new TableStorage <CopyJob>(masterStorageAccount, "completejobs"); TableStorage <ReplicationStorageAccount> accountTableStorage = new TableStorage <ReplicationStorageAccount>(masterStorageAccount, "accounts"); List <ReplicationStorageAccount> accounts = await accountTableStorage.GetAllAsync(); List <Task> tasks = new List <Task>(); Parallel.ForEach <ReplicationStorageAccount>(accounts, async(account) => { TableContinuationToken continuationToken = null; TableQuery <CopyJob> query = new TableQuery <CopyJob>().Where(TableQuery.GenerateFilterCondition("PartitionKey", QueryComparisons.Equal, account.RowKey)); CloudStorageAccount targetStorageAccount = CloudStorageAccount.Parse(account.connectionString); CloudBlobClient blobClient = targetStorageAccount.CreateCloudBlobClient(); do { var response = await copyJobTableStorage.table.ExecuteQuerySegmentedAsync(query, continuationToken); continuationToken = response.ContinuationToken; tasks.Add(Task.Run(async() => { foreach (var job in response.Results) { CloudBlobContainer container = blobClient.GetContainerReference(job.targetContainer); CloudBlockBlob blob = container.GetBlockBlobReference(job.targetBlobName); await blob.FetchAttributesAsync(); CopyState state = blob.CopyState; job.Update(state); //log.Info($"Updated {job.copyId} - status {job.copyStatus}"); if (job.copyStatus == "Success") { try { await copyCompleteJobTableStorage.InsertOrReplaceAsync(job); await copyJobTableStorage.Delete(job); //log.Info($"Deleted completed job {job.copyId}"); } catch (StorageException ex) { // log.Info($"Exception deleting CopyJob {job.copyId}: {ex.Message}"); } } else { await copyJobTableStorage.InsertOrReplaceAsync(job); } } })); }while (continuationToken != null); }); Task.WaitAll(tasks.ToArray()); }
void BlockchangeOffset(Player p, ushort x, ushort y, ushort z, byte type, byte extType) { RevertAndClearState(p, x, y, z); CopyState state = p.CopyBuffer; state.Offset.X = state.OriginX - x; state.Offset.Y = state.OriginY - y; state.Offset.Z = state.OriginZ - z; }
private void HandleFetchCopyStateResult(CopyState copyState) { if (null == copyState) { // Reach here, the destination should already exist. string exceptionMessage = string.Format( CultureInfo.CurrentCulture, Resources.FailedToRetrieveCopyStateForObjectException, this.DestUri.ToString()); throw new TransferException( TransferErrorCode.FailToRetrieveCopyStateForObject, exceptionMessage); } else { // Verify we are monitoring the right blob copying process. if (!this.TransferJob.CopyId.Equals(copyState.CopyId)) { throw new TransferException( TransferErrorCode.MismatchCopyId, Resources.MismatchFoundBetweenLocalAndServerCopyIdsException); } if (CopyStatus.Success == copyState.Status) { this.UpdateTransferProgress(copyState); this.DisposeStatusRefreshTimer(); this.SetFinished(); } else if (CopyStatus.Pending == copyState.Status) { this.UpdateTransferProgress(copyState); // Wait a period to restart refresh the status. this.RestartTimer(); } else { string exceptionMessage = string.Format( CultureInfo.CurrentCulture, Resources.FailedToAsyncCopyObjectException, this.GetSourceUri().ToString(), this.DestUri.ToString(), copyState.Status.ToString(), copyState.StatusDescription); // CopyStatus.Invalid | Failed | Aborted throw new TransferException( TransferErrorCode.AsyncCopyFailed, exceptionMessage); } } }
/// <summary> /// Builds a <see cref="CopyState"/> object from the given strings containing formatted copy information. /// </summary> /// <param name="copyStatusString">The copy status, as a string.</param> /// <param name="copyId">The copy ID.</param> /// <param name="copySourceString">The source URI of the copy, as a string.</param> /// <param name="copyProgressString">A string formatted as progressBytes/TotalBytes.</param> /// <param name="copyCompletionTimeString">The copy completion time, as a string, or null.</param> /// <param name="copyStatusDescription">The copy status description, if any.</param> /// <returns>A <see cref="CopyState"/> object populated from the given strings.</returns> internal static CopyState GetCopyAttributes( string copyStatusString, string copyId, string copySourceString, string copyProgressString, string copyCompletionTimeString, string copyStatusDescription) { CopyState copyAttributes = new CopyState { CopyId = copyId, StatusDescription = copyStatusDescription }; switch (copyStatusString) { case Constants.CopySuccessValue: copyAttributes.Status = CopyStatus.Success; break; case Constants.CopyPendingValue: copyAttributes.Status = CopyStatus.Pending; break; case Constants.CopyAbortedValue: copyAttributes.Status = CopyStatus.Aborted; break; case Constants.CopyFailedValue: copyAttributes.Status = CopyStatus.Failed; break; default: copyAttributes.Status = CopyStatus.Invalid; break; } if (!string.IsNullOrEmpty(copyProgressString)) { string[] progressSequence = copyProgressString.Split('/'); copyAttributes.BytesCopied = long.Parse(progressSequence[0], CultureInfo.InvariantCulture); copyAttributes.TotalBytes = long.Parse(progressSequence[1], CultureInfo.InvariantCulture); } if (!string.IsNullOrEmpty(copySourceString)) { copyAttributes.Source = new Uri(copySourceString); } if (!string.IsNullOrEmpty(copyCompletionTimeString)) { copyAttributes.CompletionTime = copyCompletionTimeString.ToUTCTime(); } return(copyAttributes); }
public static Method[] Copy(this IReadOnlyList <Method> candidates, CopyState state) { var result = new Method[candidates.Count]; for (int i = 0; i < candidates.Count; i++) { result[i] = state.GetMember(candidates[i]); } return(result); }
public override Expression CopyExpression(CopyState state) { var result = new Lambda(Source, Parameters.Copy(state), state.GetType(DelegateType), null); state.AddLambda(this, result); var body = Body.CopyStatement(state); result.SetBody(body); return(result); }
public override Statement CopyStatement(CopyState state) { var r = new Scope(Source); foreach (var s in Statements) { r.Statements.Add(s.CopyStatement(state)); } return(r); }
public static CatchBlock[] Copy(this CatchBlock[] c, CopyState state) { var r = new CatchBlock[c.Length]; for (var i = 0; i < c.Length; i++) { r[i] = c[i].Copy(state); } return(r); }
public CopyJob(CopyState state, string lTargetContainer, string lTargetBlobName, string lTargetUri, string targetStorageAccountId) { RowKey = state.CopyId; PartitionKey = targetStorageAccountId; targetStorageAccount = targetStorageAccountId; targetContainer = lTargetContainer; targetBlobName = lTargetBlobName; targetUri = lTargetUri; sourceUri = state.Source.ToString(); Update(state); }
public static Statement[] CopyStatements(this Statement[] list, CopyState s) { var result = new Statement[list.Length]; for (var i = 0; i < list.Length; i++) { result[i] = list[i].CopyStatement(s); } return(result); }
/// <summary> /// Builds a <see cref="CopyState"/> object from the given strings containing formatted copy information. /// </summary> /// <param name="copyStatusString">The copy status, as a string.</param> /// <param name="copyId">The copy ID.</param> /// <param name="copySourceString">The source URI of the copy, as a string.</param> /// <param name="copyProgressString">A string formatted as progressBytes/TotalBytes.</param> /// <param name="copyCompletionTimeString">The copy completion time, as a string, or null.</param> /// <param name="copyStatusDescription">The copy status description, if any.</param> /// <returns>A <see cref="CopyState"/> object populated from the given strings.</returns> internal static CopyState GetCopyAttributes( string copyStatusString, string copyId, string copySourceString, string copyProgressString, string copyCompletionTimeString, string copyStatusDescription) { CopyState copyAttributes = new CopyState { CopyId = copyId, StatusDescription = copyStatusDescription }; switch (copyStatusString) { case Constants.CopySuccessValue: copyAttributes.Status = CopyStatus.Success; break; case Constants.CopyPendingValue: copyAttributes.Status = CopyStatus.Pending; break; case Constants.CopyAbortedValue: copyAttributes.Status = CopyStatus.Aborted; break; case Constants.CopyFailedValue: copyAttributes.Status = CopyStatus.Failed; break; default: copyAttributes.Status = CopyStatus.Invalid; break; } if (!string.IsNullOrEmpty(copyProgressString)) { string[] progressSequence = copyProgressString.Split('/'); copyAttributes.BytesCopied = long.Parse(progressSequence[0]); copyAttributes.TotalBytes = long.Parse(progressSequence[1]); } if (!string.IsNullOrEmpty(copySourceString)) { copyAttributes.Source = new Uri(copySourceString); } if (!string.IsNullOrEmpty(copyCompletionTimeString)) { copyAttributes.CompletionTime = copyCompletionTimeString.ToUTCTime(); } return copyAttributes; }