Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /* ************************************************************************
  #
  #  DivConq
  #
  #  http://divconq.com/
  #
  #  Copyright:
  #    Copyright 2014 eTimeline, LLC. All rights reserved.
  #
 #  License:
 #    See the license.txt file in the project's top-level directory for details.
 #
 #  Authors:
 #    * Andy White
 #
 ************************************************************************ */
 package divconq.script.inst.file;
 
 
 public class FileOps extends Ops {
 	public void prepTarget(StackEntry stack) {
 		this.nextOpResume(stack);
 	}
 
 	public void runOp(StackEntry stackXElement opStruct target) {
 		if ("Copy".equals(op.getName())) 
 			this.copy(stackop);					
 		else if ("XCopy".equals(op.getName())) 
 			this.xcopy(stackop);
 		else if ("Tar".equals(op.getName())) 
 			this.injectStream(stackopnew TarStream());					
 		else if ("Untar".equals(op.getName())) 
 			this.injectStream(stackopnew UntarStream());					
 		else if ("Gzip".equals(op.getName())) 
 			this.injectStream(stackopnew GzipStream());
 		else if ("Ungzip".equals(op.getName())) 
 			this.injectStream(stackopnew UngzipStream());
 		else if ("Funnel".equals(op.getName())) 
 			this.injectStream(stackopnew FunnelStream());
 		else if ("Split".equals(op.getName())) 
 			this.injectStream(stackopnew SplitStream());
 		else if ("Join".equals(op.getName())) 
 			this.injectStream(stackopnew JoinStream());
 		else {
 			stack.log().error("Unknown FileOp: " + op.getName());
 			this.nextOpResume(stack);
 		}
 	}
 
 	protected void copy(StackEntry stackXElement el) {
 		IStreamSource streamin = this.getSourceStream(stackel);
 		
 		if (streamin != null)
 			this.executeDest(stackelstreaminfalsetrue);
 	}
 
 	protected void xcopy(StackEntry stackXElement el) {
 		IStreamSource streamin = this.getSourceStream(stackel);
 		
 		if (streamin != null)
 			this.executeDest(stackelstreamintruetrue);
 	}
 
 	protected void injectStream(StackEntry stackXElement elIStreamSource add) {
 		IStreamSource streamin = this.getSourceStream(stackel);
 		
 		if (streamin == null
 			return;
 		
 		add.init(stackel);
		add.setUpstream(streamin);
		this.registerSourceStream(stackeladd);
        this.executeDest(stackeladdtruefalse);
	}
	protected IStreamSource getSourceStream(StackEntry stackXElement el) {
        Struct src = stack.refFromElement(el"Source");
        
        if ((src == null) || (src instanceof NullStruct)) {
        	src = stack.queryVariable("_LastStream");
        	
            if ((src == null) || (src instanceof NullStruct)) {
	        	stack.log().error("Missing source");
				this.nextOpResume(stack);
	        	return null;
            }
        }
        
        if (src instanceof IStreamSource)
        	return (IStreamSourcesrc;
        
        if (!(src instanceof IFileStoreFile) && !(src instanceof IFileStoreDriver) && !(src instanceof IFileCollection)) {
        	stack.log().error("Invalid source type");
			this.nextOpResume(stack);
        	return null;
        }
        
		IStreamSource filesrc = null;
        if (src instanceof IFileStoreFile
        	filesrc = ((IFileStoreFile)src).allocSrc();
        else if (src instanceof IFileStoreDriver
       		filesrc = ((IFileStoreDriver)src).rootFolder().allocSrc();
        else 
        	filesrc = new FileSourceStream((IFileCollectionsrc); 
        
        if (filesrc == null) {
        	stack.log().error("Invalid source type");
			this.nextOpResume(stack);
        	return null;
        }
        
        filesrc.init(stackel);
        
		return filesrc;
	}
	protected IStreamDest getDestStream(StackEntry stackXElement elboolean autorelative) {
        Struct dest = stack.refFromElement(el"Dest");
        
        if ((dest == null) || (dest instanceof NullStruct)) 
        	return null;
        
        if ((dest instanceof StringStruct) && "NULL".equals(((StringStruct)dest).getValue()))
        	return new NullStream();
        
        if (dest instanceof IStreamDest)
        	return (IStreamDestdest;
        
        if (!(dest instanceof IFileStoreFile) && !(dest instanceof IFileStoreDriver)) {
        	stack.log().error("Invalid dest type");
			this.nextOpResume(stack);
        	return null;
        }
        
        IStreamDest deststrm = null;
        
        if (dest instanceof IFileStoreDriver
        	deststrm = ((IFileStoreDriver)dest).rootFolder().allocDest();
        else 
        	deststrm = ((IFileStoreFile)dest).allocDest();
        
        if (deststrm == null) {
        	stack.log().error("Unable to create destination stream");
			this.nextOpResume(stack);
        	return null;
        }
        
        deststrm.init(stackelautorelative);
        return deststrm;
	}
	protected void executeDest(StackEntry stackXElement elIStreamSource srcboolean autorelativeboolean destRequired) {
		stack.addVariable("_LastStream", (Struct)src);
		IStreamDest streamout = this.getDestStream(stackelautorelative);
        
        if (streamout != null) {
    		streamout.setUpstream(src);
    		
    		IWork sw = new StreamWork(streamout);
    		
    		Task t = Task.subtask(stack.getActivity().getTaskRun(), "Streaming"new OperationCallback() {
    			@Override
    			public void callback() {
    				FileOps.this.nextOpResume(stack);
    	        	return;
    			}
    		});
    		
    		t.withWork(sw);
    		
    		TaskRun run = new TaskRun(t);
    		
    		run.addCloseable(streamout);
        }
        else {
        	if (destRequired)
        		stack.log().error("Missing dest for " + el.getName());
        	
			this.nextOpResume(stack);
        	return;
        }
	}
	protected void registerSourceStream(StackEntry stackXElement elIStreamSource src) {
        String name = stack.stringFromElement(el"Name");
        
        if (StringUtil.isEmpty(name))
        	name = "Stream_" + stack.getActivity().tempVarName();
        
        // to be sure we cleanup the stream, all variables added will later be disposed of
        stack.addVariable(name, (Struct)src);
	}
	public void cancel(StackEntry stack) {
		// TODO review after we make operations
	}
New to GrepCode? Check out our FAQ X