Big-Data-HPC-Platform/esp/scm/ws_fs.ecm

/*##############################################################################

    HPCC SYSTEMS software Copyright (C) 2012 HPCC Systems®.

    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.
    You may obtain a copy of the License at

       http://www.apache.org/licenses/LICENSE-2.0

    Unless required by applicable law or agreed to in writing, software
    distributed under the License is distributed on an "AS IS" BASIS,
    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    See the License for the specific language governing permissions and
    limitations under the License.
############################################################################## */

ESPenum DFUWUActions : string
{
    Delete("Delete"),
    Protect("Protect"),
    Unprotect("Unprotect"),
    Restore("Restore"),
    SetToFailed("SetToFailed"),
};

ESPStruct [nil_remove] DFUWorkunit
{
    string ID;
    [min_ver("1.06")] string DFUServerName;
    string ClusterName;
    string JobName;
    string Queue;
    string User;
    bool isProtected;
    int Command;
    [min_ver("1.03")] string CommandMessage;

    int PercentDone;
    int SecsLeft;
    string ProgressMessage;
    string SummaryMessage;
    int State;

    string SourceLogicalName;

    string SourceIP;
    string SourceFilePath;
    string SourceDali;
    int SourceRecordSize;
    int SourceFormat;
    string RowTag;

    int SourceNumParts;
    string SourceDirectory;

    string DestLogicalName;
    string DestGroupName;
    string DestDirectory;

    string DestIP;
    string DestFilePath;
    int DestFormat;

    int DestNumParts;
    int DestRecordSize;
    bool Replicate;
    bool Overwrite;
    bool Compress;

    [min_ver("1.04")] string SourceCsvSeparate;
    [min_ver("1.04")] string SourceCsvQuote;
    [min_ver("1.04")] string SourceCsvTerminate;
    [min_ver("1.05")] string SourceCsvEscape;

    string TimeStarted;
    string TimeStopped;
    string StateMessage;

    // Monitor
    string MonitorEventName;
    bool MonitorSub;                
    int MonitorShotLimit;

    string SourceDiffKeyName;
    string DestDiffKeyName;
    [min_ver("1.03")] bool Archived(false);

    string encrypt;
    string decrypt;

    [min_ver("1.08")] bool failIfNoSourceFile(false);
    [min_ver("1.09")] bool recordStructurePresent(false);
    [min_ver("1.10")] bool quotedTerminator(true);
    [min_ver("1.12")] bool preserveCompression(true);
};

ESPStruct [nil_remove] GroupNode
{
    string Name;
    string ClusterType;
    bool ReplicateOutputs;
};

ESPStruct DFUException
{
    int Code;
    string Message;
};

ESPStruct [nil_remove] DFUActionResult
{
    string ID;
    string Action;
    string Result;
};

ESPrequest 
[
]
DFUWUSearchRequest
{
};

ESPresponse 
[
   exceptions_inline
]
DFUWUSearchResponse
{
    ESParray<string, ClusterName> ClusterNames;
};


ESPrequest GetDFUWorkunits
{
    [min_ver("1.12")] string Wuid;
    string Owner;
    string Cluster;
    string StateReq;
    [min_ver("1.03")] string Type;
    [min_ver("1.03")] string Jobname;

    int64 PageSize;
    int CurrentPage; //Not used
    [min_ver("1.01")] int64 PageStartFrom(-1);
    string Sortby;
    bool Descending(false);
    int64 CacheHint(-1);
};

ESPresponse [encode(0), exceptions_inline]
GetDFUWorkunitsResponse
{
    ESParray<ESPstruct DFUWorkunit> results;

    [min_ver("1.03")] string Type;
    string Owner;
    string Cluster;
    string StateReq;

    int64 PageSize;
    int64 PrevPage;
    int64 NextPage;
    [min_ver("1.01")] int64 LastPage(-1);
    int64 NumWUs;
    [min_ver("1.01")] int64 PageStartFrom(-1);
    [min_ver("1.01")] int64 PageEndAt;
    bool First(true);
    string Sortby;
    bool Descending(false);
    string BasicQuery;
    string Filters;
    [min_ver("1.07")] int64 CacheHint;
 };

ESPrequest [exceptions_inline] ProgressRequest
{
    string wuid;
};

ESPresponse [encode(0), exceptions_inline] ProgressResponse
{
    string wuid;
    int PercentDone;
    int SecsLeft;
    int KbPerSecAve;
    int KbPerSec;
    int SlavesDone;
    string TimeTaken;
    string ProgressMessage;
    string SummaryMessage;
    string State;
};

ESPrequest GetDFUWorkunit
{
    string wuid;
};

ESPresponse [exceptions_inline]
GetDFUWorkunitResponse
{
    ESPstruct DFUWorkunit result;
    int  AutoRefresh(0);
};

ESPrequest CreateDFUWorkunit
{
};

ESPresponse [exceptions_inline]
CreateDFUWorkunitResponse
{
    ESPstruct DFUWorkunit result;
};

ESPrequest UpdateDFUWorkunit
{
    ESPstruct DFUWorkunit wu;
    string ClusterOrig;
    string JobNameOrig;
    bool isProtectedOrig;
    int StateOrig;
};

ESPresponse [exceptions_inline]
UpdateDFUWorkunitResponse
{
};

ESPrequest DeleteDFUWorkunit
{
    string wuid;
};

ESPresponse [exceptions_inline]
DeleteDFUWorkunitResponse
{
    bool result;
};

ESPrequest DeleteDFUWorkunits
{
    ESParray<string> wuids;
};

ESPresponse [exceptions_inline]
DeleteDFUWorkunitsResponse
{
};

ESPrequest DFUWorkunitsActionRequest
{
    ESParray<string> wuids;
    ESPenum DFUWUActions Type;
};

ESPresponse [exceptions_inline] DFUWorkunitsActionResponse
{
    string FirstColumn("WUID");
    ESParray<ESPstruct DFUActionResult> DFUActionResults;
};

ESPrequest SubmitDFUWorkunit
{
    string wuid;
};

ESPresponse [exceptions_inline] 
SubmitDFUWorkunitResponse
{
};

ESPrequest AbortDFUWorkunit
{
    string wuid;
};

ESPresponse [exceptions_inline] 
AbortDFUWorkunitResponse
{
};

ESPrequest GetDFUExceptions
{
    string wuid;
};

ESPresponse [exceptions_inline] 
GetDFUExceptionsResponse
{
    ESParray<ESPstruct DFUException> result;
};

ESPrequest [nil_remove] SprayFixed
{
    string sourceIP;
    string sourcePath;
    binary srcxml;
    [min_ver("1.09")] string sourceFormat;
    int sourceRecordSize;

    string destGroup;
    string destLogicalName;
    bool   overwrite;
    bool   replicate;
    int    ReplicateOffset(1);

    int    maxConnections;
    int    throttle;
    int    transferBufferSize;

    string prefix;
    bool   nosplit(false);
    bool   norecover(false);
    bool   compress(false);
    bool   push(false);
    bool   pull(false);

    string encrypt;
    string decrypt;
    bool   wrap(false);

    [min_ver("1.08")] bool failIfNoSourceFile(false);

    [min_ver("1.09")] bool recordStructurePresent(false);

    [min_ver("1.10")] bool quotedTerminator(true);
};

ESPresponse [exceptions_inline] 
SprayFixedResponse 
{
    string wuid;
};

ESPrequest [nil_remove] SprayVariable
{
    string sourceIP;
    string sourcePath;
    binary srcxml;
    
    int sourceMaxRecordSize;
    int sourceFormat;
    bool   NoSourceCsvSeparator(false);
    string sourceCsvSeparate;
    string sourceCsvTerminate;
    string sourceCsvQuote;
    string sourceCsvEscape;
    string sourceRowTag;

    string destGroup;
    string destLogicalName;
    bool   overwrite;
    bool   replicate;
    int    ReplicateOffset(1);

    int    maxConnections;
    int    throttle;    
    int    transferBufferSize;

    string prefix;
    bool   nosplit(false);
    bool   norecover(false);    
    bool   compress(false);
    bool   push(false);
    bool   pull(false);

    string encrypt;
    string decrypt;

    [min_ver("1.08")] bool failIfNoSourceFile(false);

    [min_ver("1.09")] bool recordStructurePresent(false);

    [min_ver("1.10")] bool quotedTerminator(true);
    [min_ver("1.11")] string sourceRowPath;
    [min_ver("1.11")] bool isJSON(false);
};

ESPresponse [exceptions_inline] 
SprayResponse 
{
    string wuid;
};

ESPrequest [nil_remove] Replicate
{
    string sourceLogicalName;
    int    replicateOffset(1);
    string cluster;
    bool   repeatLast(false);
    bool   onlyRepeated(false);
};  

ESPresponse [exceptions_inline] 
ReplicateResponse
{
    string wuid;
};

ESPrequest Despray
{
    string sourceLogicalName;

    string destIP;
    string destPath;
    binary dstxml;
    bool   overwrite;

    int    maxConnections;
    int    throttle;    
    int    transferBufferSize;

    string splitprefix;
    bool   norecover(false);
    bool   wrap(false);
    bool   multiCopy(false);
    [min_ver("1.02")] bool SingleConnection;

    bool   compress(false);
    string encrypt;
    string decrypt;

};  

ESPresponse [exceptions_inline] 
DesprayResponse
{
    string wuid;
};

ESPrequest [nil_remove] Copy
{
    string sourceLogicalName;
    string destGroup;
    string destGroupRoxie;
    string destLogicalName;
    string sourceDali;
    string srcusername;
    string srcpassword;
    bool   overwrite;
    bool   replicate;
    int    ReplicateOffset(1);

    int    maxConnections;
    int    throttle;    
    int    transferBufferSize;
    bool   nosplit;
    bool   norecover(false);
    bool   compress(false);
    bool   Wrap(false);
    bool   Multicopy(false);
    //bool   Farmers(false);
    string SourceDiffKeyName;
    string DestDiffKeyName;
    bool   superCopy(false);
    bool   push(false);
    bool   pull(false);
    bool   ifnewer(false);

    string encrypt;
    string decrypt;

    [min_ver("1.12")] bool preserveCompression(true);
};

ESPresponse [exceptions_inline] 
CopyResponse
{
    string result;
};

ESPrequest EchoDateTime
{
    xsdDateTime dt;
};

ESPresponse EchoDateTimeResponse
{
    xsdDateTime result;
};

ESPrequest Rename
{
    string srcname;
    string dstname;
    bool   overwrite;
};

ESPresponse [exceptions_inline] 
RenameResponse
{
    string wuid;
};

ESPrequest DFUWUFileRequest
{
    string Wuid;
    string Type;
    string  PlainText;
};

ESPresponse [exceptions_inline] DFUWUFileResponse
{
    [http_content("text/xml")] string file;
};

ESPrequest FileListRequest
{
    string Netaddr;
    string Path;
    string Mask;
    string OS;
    bool DirectoryOnly(false);
};

ESPStruct PhysicalFileStruct
{
    string name;
    bool isDir;
    int64 filesize;
    string modifiedtime;
    [min_ver("1.13")] string Path;
    [min_ver("1.13")] ESParray<ESPstruct PhysicalFileStruct> Files;
};

ESPresponse [exceptions_inline] FileListResponse
{
    string Netaddr;
    string Path;
    string Mask;
    int    OS;
    bool DirectoryOnly(false);
    [min_ver("1.10")] string AcceptLanguage;
    ESParray<ESPStruct PhysicalFileStruct> files;   
};

ESPrequest [nil_remove] DropZoneFileSearchRequest
{
    string DropZoneName;
    string NameFilter;
};

ESPresponse [exceptions_inline] DropZoneFileSearchResponse
{
    ESParray<ESPStruct PhysicalFileStruct> Files;
};

ESPrequest OpenSaveRequest
{
    string Location;
    string Path;
    string Name;
    string Type;
    string DateTime;
    bool BinaryFile(false);
};

ESPresponse [exceptions_inline] OpenSaveResponse
{
    string Location;
    string Path;
    string Name;
    string Type;
    string DateTime;
    bool Viewable(true);
};

ESPrequest DfuMonitorRequest
{
    string EventName;
    string LogicalName;
    string Ip;
    string Filename;
    bool   Sub;
    int    ShotLimit;
};

ESPresponse [exceptions_inline] DfuMonitorResponse
{
    string wuid;
};

ESPrequest ShowResultRequest
{
    string Result;
};

ESPresponse [exceptions_inline] ShowResultResponse
{
    string Result;
};


ESPStruct [nil_remove] DropZone
{
    string Name;
    string NetAddress;
    string Path;
    string Computer;
    string Linux;                          
};

ESPrequest DropZoneFilesRequest
{
    string NetAddress;
    string Path;
    string OS;
    string Subfolder;
    bool DirectoryOnly(false);
};

ESPresponse [exceptions_inline, nil_remove] DropZoneFilesResponse
{
    string NetAddress;
    string Path;
    int OS;

    ESParray<ESPStruct DropZone> DropZones; 
    ESParray<ESPStruct PhysicalFileStruct> Files;   
};

ESPrequest DeleteDropZoneFilesRequest
{
    string NetAddress;
    string Path;
    string OS;

    ESParray<string> Names;
};

ESPresponse [exceptions_inline, nil_remove] DeleteDropZoneFilesResponse
{
    ESParray<ESPstruct DFUActionResult> DFUActionResults;
};

ESPresponse [exceptions_inline] UploadFilesResponse
{
    ESParray<ESPstruct DFUActionResult> UploadFileResults;
};

ESPrequest GetSprayTargetsRequest
{
};

ESPresponse [exceptions_inline, nil_remove] GetSprayTargetsResponse
{
    ESParray<ESPstruct GroupNode, GroupNode> GroupNodes; 
};

ESPservice [
    auth_feature("DEFERRED"),
    version("1.13"),
    exceptions_inline("./smc_xslt/exceptions.xslt")] FileSpray
{
    ESPuses ESPstruct DFUWorkunit;
    ESPuses ESPstruct DFUException;
    ESPmethod EchoDateTime(EchoDateTime, EchoDateTimeResponse);
    ESPmethod [resp_xsl_default("/esp/xslt/showresult.xslt")] ShowResult(ShowResultRequest, ShowResultResponse);
    ESPmethod [resp_xsl_default("/esp/xslt/dfuwu_search.xslt")] DFUWUSearch(DFUWUSearchRequest, DFUWUSearchResponse);
    ESPmethod [resp_xsl_default("/esp/xslt/dfu_workunits.xslt")] GetDFUWorkunits(GetDFUWorkunits, GetDFUWorkunitsResponse);
    ESPmethod [resp_xsl_default("/esp/xslt/dfu_wuid.xslt")] GetDFUWorkunit(GetDFUWorkunit, GetDFUWorkunitResponse);
    ESPmethod [resp_xsl_default("/esp/xslt/dfu_progress.xslt")] GetDFUProgress(ProgressRequest, ProgressResponse);

    ESPmethod [resp_xsl_default("/esp/xslt/dfu_wuid.xslt")] CreateDFUWorkunit(CreateDFUWorkunit, CreateDFUWorkunitResponse);
    ESPmethod [resp_xsl_default("/esp/xslt/dfu_wuid.xslt")] UpdateDFUWorkunit(UpdateDFUWorkunit, UpdateDFUWorkunitResponse);
    ESPmethod DeleteDFUWorkunit(DeleteDFUWorkunit, DeleteDFUWorkunitResponse);
    ESPmethod DeleteDFUWorkunits(DeleteDFUWorkunits, DeleteDFUWorkunitsResponse);
    ESPmethod [resp_xsl_default("/esp/xslt/dfuwuaction_results.xslt")] DFUWorkunitsAction(DFUWorkunitsActionRequest, DFUWorkunitsActionResponse);
    ESPmethod [resp_xsl_default("/esp/xslt/dfu_wuid.xslt")] SubmitDFUWorkunit(SubmitDFUWorkunit, SubmitDFUWorkunitResponse);
    ESPmethod [resp_xsl_default("/esp/xslt/dfu_wuid.xslt")] AbortDFUWorkunit(AbortDFUWorkunit, AbortDFUWorkunitResponse);
    ESPmethod GetDFUExceptions(GetDFUExceptions, GetDFUExceptionsResponse);

    ESPmethod SprayFixed(SprayFixed, SprayFixedResponse);
    ESPmethod SprayVariable(SprayVariable, SprayResponse);
    ESPmethod Despray(Despray, DesprayResponse);
    ESPmethod Copy(Copy, CopyResponse);
    ESPmethod Rename(Rename, RenameResponse);
    ESPmethod Replicate(Replicate, ReplicateResponse);
    ESPmethod DFUWUFile(DFUWUFileRequest, DFUWUFileResponse);
    ESPmethod DfuMonitor(DfuMonitorRequest, DfuMonitorResponse);
    ESPmethod [resp_xsl_default("/esp/xslt/dfu_filelist.xslt")] FileList(FileListRequest, FileListResponse);
    ESPmethod [resp_xsl_default("/esp/xslt/opensave.xslt")] OpenSave(OpenSaveRequest, OpenSaveResponse);
    ESPmethod [resp_xsl_default("/esp/xslt/dropzonefile.xslt")] DropZoneFiles(DropZoneFilesRequest, DropZoneFilesResponse);
    ESPmethod [resp_xsl_default("/esp/xslt/dfuwuaction_results.xslt")] DeleteDropZoneFiles(DeleteDropZoneFilesRequest, DFUWorkunitsActionResponse);
    ESPmethod [min_ver("1.13")] DropZoneFileSearch(DropZoneFileSearchRequest, DropZoneFileSearchResponse);
    ESPmethod GetSprayTargets(GetSprayTargetsRequest, GetSprayTargetsResponse);
};

SCMexportdef(FileSpray);

SCMapi(FileSpray) IClientFileSpray *createFileSprayClient();