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

/*##############################################################################
HPCC SYSTEMS software Copyright (C) 2012 HPCC Systems®.
############################################################################## */

ESPrequest EchoRequest
{
    string Request;
};

ESPresponse EchoResponse
{
    string Response;
};

ESPstruct BasePackageStatus
{
    int Code;
    string Description;
};

ESPstruct PackageMapEntry
{
    string Id;
    string Target;
    string Process;
};

ESPrequest AddPackageRequest
{
    string Info;
    boolean Activate;
    boolean OverWrite; //use flags below unless you really want to overwrite the actual file metadata and packagemap
    string Target;
    string PackageMap;
    string Process;
    string DaliIp;
    bool GlobalScope(0);
    string SourceProcess;
    bool AllowForeignFiles(true);
    [min_ver("1.02")] bool PreloadAllPackages(false);
    bool ReplacePackageMap(false);
    bool UpdateSuperFiles(false); //usually wouldn't be needed, packagemap referencing superfiles?
    bool UpdateCloneFrom(false); //explicitly wan't to change where roxie will grab from
    bool AppendCluster(true); //file exists on other local cluster, add new one, make optional in case of locking issues, but should be made to work
};


ESPresponse [exceptions_inline] AddPackageResponse
{
    ESPstruct BasePackageStatus status;
    ESParray<string, File> FilesNotFound;
};

ESPrequest CopyPackageMapRequest
{
    string SourcePath;
    string RemoteUserName;
    [password] string RemotePassword;
    string Target;
    string Process;
    string PMID;
    boolean Activate;
    string DaliIp;
    bool GlobalScope(0);
    string SourceProcess;
    bool PreloadAllPackages(false);
    bool ReplacePackageMap(false);
    bool UpdateSuperFiles(false); //usually wouldn't be needed, packagemap referencing superfiles?
    bool UpdateCloneFrom(false); //explicitly wan't to change where roxie will grab from
    bool AppendCluster(true); //file exists on other local cluster, add new one, make optional in case of locking issues, but should be made to work
};

ESPresponse [exceptions_inline] CopyPackageMapResponse
{
    ESPstruct BasePackageStatus status;
    ESParray<string, File> FilesNotFound;
};

ESPrequest DeletePackageRequest
{
    string Target;
    string PackageMap;
    string Process;
    bool GlobalScope(0);
    ESParray<ESPstruct PackageMapEntry, PackageMap> PackageMaps;
};

ESPresponse [exceptions_inline] DeletePackageResponse
{
    ESPstruct BasePackageStatus status;
};

ESPrequest ActivatePackageRequest
{
    string Target;
    string PackageMap;
    string Process;
    bool GlobalScope(0);
};

ESPresponse [exceptions_inline] ActivatePackageResponse
{
    ESPstruct BasePackageStatus status;
};

ESPrequest DeActivatePackageRequest
{
    string Target;
    string PackageMap;
    string Process;
    bool GlobalScope(0);
};

ESPresponse [exceptions_inline] DeActivatePackageResponse
{
    ESPstruct BasePackageStatus status;
};

ESPrequest GetPackageRequest
{
    string Target;
    string Process;
};

ESPresponse [exceptions_inline] GetPackageResponse
{
    ESPstruct BasePackageStatus status;
    string Info;
};

ESPrequest GetPackageMapByIdRequest
{
    string PackageMapId;
};

ESPresponse [exceptions_inline] GetPackageMapByIdResponse
{
    ESPstruct BasePackageStatus status;
    string Info;
};

ESPrequest ListPackageRequest
{
    string Target;
    string Process;
};

ESPstruct PackageListData
{
    string Id;
    string Queries;
};

ESPstruct PackageListMapData
{
    string Id;
    string Target;
    [min_ver("1.01")] string Process;
    ESParray<ESPstruct PackageListData> PkgListData;
    boolean Active;
    [min_ver("1.01")] string Description;
};

ESPresponse [exceptions_inline] ListPackageResponse
{
    ESPstruct BasePackageStatus status;
    ESParray<ESPstruct PackageListMapData> PkgListMapData;
};

ESPrequest [nil_remove] ListPackagesRequest
{
    string Target;
    string Process;
    string ProcessFilter;
};

ESPresponse [nil_remove, exceptions_inline] ListPackagesResponse
{
    ESPstruct BasePackageStatus status;
    ESParray<ESPstruct PackageListMapData> PackageMapList;
};

ESPrequest ValidatePackageRequest
{
    string Info;
    string Target;
    string Process;
    bool Active;
    string PMID;
    string QueryIdToVerify;
    ESParray<string> QueriesToVerify;
    ESParray<string> QueriesToIgnore;
    bool CheckDFS;
    bool GlobalScope(0);
    bool IgnoreWarnings(0);
    bool IgnoreOptionalFiles(0);
};

ESPstruct ValidatePackageInfo
{
    ESParray<string> Unmatched;
};

ESPstruct ValidatePackageQueries
{
    ESParray<string> Unmatched;
};

ESPstruct ValidatePackageFiles
{
    ESParray<string> Unmatched;
    ESParray<string, File> NotInDFS;
};

ESPresponse [exceptions_inline] ValidatePackageResponse
{
    string PMID;
    ESPstruct BasePackageStatus status;
    ESParray<string> Warnings;
    ESParray<string> Errors;
    ESPstruct ValidatePackageInfo packages;
    ESPstruct ValidatePackageQueries queries;
    ESPstruct ValidatePackageFiles files;
};

ESPrequest GetQueryFileMappingRequest
{
    string Target;
    string PMID;
    string QueryName;
    bool GlobalScope(0);
};

ESPstruct SuperFile
{
    string Name;
    ESParray<string, File> SubFiles;
};

ESPresponse [exceptions_inline] GetQueryFileMappingResponse
{
    ESParray<string, File> UnmappedFiles;
    ESParray<ESPstruct SuperFile> SuperFiles;
};


ESPstruct TargetData
{
    string Name;
    string Type;
    ESParray<string> Processes;
};

ESPrequest GetPackageMapSelectOptionsRequest
{
    bool IncludeTargets(true);
    bool IncludeProcesses(true);
    bool IncludeProcessFilters(true);
};

ESPresponse [exceptions_inline] GetPackageMapSelectOptionsResponse
{
    ESPstruct BasePackageStatus status;
    ESParray<ESPstruct TargetData> Targets;
    ESParray<string> ProcessFilters;
};

ESPrequest AddPartToPackageMapRequest
{
    string Target;
    string Process;
    string PackageMap;
    bool GlobalScope(false);
    string PartName;
    string Content;
    boolean DeletePrevious;
    string DaliIp;
    string SourceProcess;
    bool AllowForeignFiles(true);
    bool PreloadAllPackages(false);
    bool UpdateSuperFiles(false); //usually wouldn't be needed, packagemap referencing superfiles?
    bool UpdateCloneFrom(false); //explicitly wan't to change where roxie will grab from
    bool AppendCluster(true); //file exists on other local cluster, add new one, make optional in case of locking issues, but should be made to work
};

ESPresponse [exceptions_inline] AddPartToPackageMapResponse
{
    ESPstruct BasePackageStatus status;
    ESParray<string, File> FilesNotFound;
};

ESPrequest RemovePartFromPackageMapRequest
{
    string Target;
    string PackageMap;
    bool GlobalScope(0);
    string PartName;
};

ESPresponse [exceptions_inline] RemovePartFromPackageMapResponse
{
    ESPstruct BasePackageStatus status;
};

ESPrequest GetPartFromPackageMapRequest
{
    string Target;
    string PackageMap;
    bool GlobalScope(0);
    string PartName;
};

ESPresponse [exceptions_inline] GetPartFromPackageMapResponse
{
    ESPstruct BasePackageStatus status;
    string Content;
};

ESPservice [auth_feature("NONE"), version("1.03"), exceptions_inline("./smc_xslt/exceptions.xslt")] WsPackageProcess
{
    ESPmethod Echo(EchoRequest, EchoResponse);
    ESPmethod [auth_feature("PackageMapAccess:WRITE")] AddPackage(AddPackageRequest, AddPackageResponse);
    ESPmethod [auth_feature("PackageMapAccess:WRITE")] CopyPackageMap(CopyPackageMapRequest, CopyPackageMapResponse);
    ESPmethod [auth_feature("PackageMapAccess:FULL")] DeletePackage(DeletePackageRequest, DeletePackageResponse);
    ESPmethod [auth_feature("PackageMapAccess:WRITE")] ActivatePackage(ActivatePackageRequest, ActivatePackageResponse);
    ESPmethod [auth_feature("PackageMapAccess:WRITE")] DeActivatePackage(DeActivatePackageRequest, DeActivatePackageResponse);
    ESPmethod [auth_feature("PackageMapAccess:READ")] ListPackage(ListPackageRequest, ListPackageResponse);
    ESPmethod [auth_feature("PackageMapAccess:READ")] ListPackages(ListPackagesRequest, ListPackagesResponse);
    ESPmethod [auth_feature("PackageMapAccess:READ")] GetPackage(GetPackageRequest, GetPackageResponse);
    ESPmethod [auth_feature("PackageMapAccess:READ")] GetPackageMapById(GetPackageMapByIdRequest, GetPackageMapByIdResponse);
    ESPmethod [auth_feature("PackageMapAccess:READ")] ValidatePackage(ValidatePackageRequest, ValidatePackageResponse);
    ESPmethod [auth_feature("PackageMapAccess:READ")] GetQueryFileMapping(GetQueryFileMappingRequest, GetQueryFileMappingResponse);
    ESPmethod [auth_feature("PackageMapAccess:READ")] GetPackageMapSelectOptions(GetPackageMapSelectOptionsRequest, GetPackageMapSelectOptionsResponse);
    ESPmethod [auth_feature("PackageMapAccess:WRITE")] AddPartToPackageMap(AddPartToPackageMapRequest, AddPartToPackageMapResponse);
    ESPmethod [auth_feature("PackageMapAccess:WRITE")] RemovePartFromPackageMap(RemovePartFromPackageMapRequest, RemovePartFromPackageMapResponse);
    ESPmethod [auth_feature("PackageMapAccess:READ")] GetPartFromPackageMap(GetPartFromPackageMapRequest, GetPartFromPackageMapResponse);
};

SCMexportdef(WsPackageProcess);

SCMapi(WsPackageProcess) IClientWsPackageProcess *createWsPackageProcessClient();