public static T OpenTask <T>(Common.Configurator config, long task_data_id) where T : Common.Tasks.AbstractBaseTask
{
Common.Tasks.AbstractBaseTask task = createInstance(typeof(T), config);
if (task != null)
{
task.TaskDataID = task_data_id;
}
return((T)task);
}
public void Init(Common.Configurator config, Models.ParameterSet parameter, Models.Service service)
{
Config = config;
Description = service.description;
ID = service.id;
this.service = service;
parameterSet = parameter;
STATE = ServiceCommonType.ServiceState.Initializing;
init(parameter, service);
STATE = ServiceCommonType.ServiceState.Stop;
}
protected StatusCode(int id, Object[] arguments, Exception ex, Common.Configurator config, short app_id)
{
_error_id = id;
_arguments = arguments;
_ex = ex;
_instance_id = config.UniqueInstanceIDPerMachine;
_region = config.Region;
_config = config;
_application_id = app_id;
doRegister();
}
//For Inherited Class Constructor
protected StatusCode(int id, Object[] arguments, Common.Configurator config, short app_id)
{
_error_id = id;
_arguments = arguments;
System.Diagnostics.StackTrace trace = new System.Diagnostics.StackTrace(true);
_frame = trace.GetFrame(1);
_instance_id = config.UniqueInstanceIDPerMachine;
_region = config.Region;
_application_id = app_id;
_config = config;
doRegister();
}
public StatusCode(int id, Common.Configurator config)
{
_error_id = id;
_arguments = null;
System.Diagnostics.StackTrace trace = new System.Diagnostics.StackTrace(true);
_frame = trace.GetFrame(1);
_instance_id = config.UniqueInstanceIDPerMachine;
_region = config.Region;
_config = config;
_application_id = _config.ApplicationID;
doRegister();
}
private static Common.Tasks.AbstractBaseTask createInstance(Type task_type, Common.Configurator config)
{
Common.Tasks.AbstractBaseTask abstractTask = null;
try
{
Assembly found_assembly = task_type.Assembly;
abstractTask = (Common.Tasks.AbstractBaseTask)found_assembly.CreateInstance(task_type.FullName);
}
catch (Exception)
{
return(null);
}
if (abstractTask != null)
{
abstractTask.Config = config;
}
return(abstractTask);
}
public static StatusCode InvalidArgumentStatus(string summary, Common.Configurator config, short app_id)
{
object[] arguments = new object[1];
arguments[0] = summary;
return(new StatusCode(INVALID_ARGUMENT_ERROR, arguments, config, app_id));
}
public Email(short app_id, Common.Configurator config)
{
_app_id = app_id;
Config = config;
}
public static Common.Tasks.AbstractBaseTask OpenTask(string assembly_name, string full_name, Common.Configurator config, long task_data_id)
{
Common.Tasks.AbstractBaseTask task = CreateInstance(assembly_name, full_name, config);
if (task != null)
{
task.TaskDataID = task_data_id;
}
return(task);
}
public static StatusCode Debug(string argument, Common.Configurator config)
{
object[] arguments = new object[1];
arguments[0] = argument;
return(new StatusCode(DEBUG_COMMENT, arguments, config));
}
public static List <Common.Tasks.AbstractBaseTask> ListupDelegatedTasks(short application_id, short task_id, Common.Configurator config)
{
List <Models.TaskData> taskDataList = Common.GyomuDataAccess.SelectTaskDataByApplicationIDTaskIDStatusUserList
(application_id, task_id, Common.Tasks.AbstractBaseTask.STATUS_DELEGATE,
new List <string>()
{
config.User.UserID
});
List <Common.Tasks.AbstractBaseTask> lstTask = new List <Common.Tasks.AbstractBaseTask>();
Models.TaskInfo taskInfo = Common.GyomuDataAccess.SelectTaskInfo(application_id, task_id);
foreach (Models.TaskData taskData in taskDataList)
{
Common.Tasks.AbstractBaseTask task = OpenTask(taskInfo.assembly_name, taskInfo.class_name, config ?? Common.BaseConfigurator.GetInstance(), taskData.id);
lstTask.Add(task);
}
return(lstTask);
}
public static T CreateNewTask <T>(Common.Configurator config) where T : Common.Tasks.AbstractBaseTask
{
return((T)createInstance(typeof(T), config));
}
public static StatusCode UnarchiveAllAndCreateDestinationFolderIfNotExist(string archiveFilename, ArchiveType archiveType, Models.FileTransportInfo transport, Common.Configurator Config, short ApplicationID, string password = null)
{
if (transport == null)
{
return(StatusCode.InvalidArgumentStatus("Transportation Information Not Specified to archive", Config, ApplicationID));
}
FileInfo archiveInfo = new System.IO.FileInfo(archiveFilename);
if (archiveType == ArchiveType.GuessFromFileName)
{
switch (archiveInfo.Extension.ToUpper())
{
case ".ZIP":
archiveType = ArchiveType.Zip;
break;
case ".TGZ":
archiveType = ArchiveType.TGZ;
break;
case ".BZ2":
archiveType = ArchiveType.BZip2;
break;
case ".GZ":
archiveType = ArchiveType.GZip;
break;
case ".TAR":
archiveType = ArchiveType.Tar;
break;
default:
return(StatusCode.InvalidArgumentStatus("File Extension Not supported for archiving", Config, ApplicationID));
}
}
if (archiveType == ArchiveType.BZip2 || archiveType == ArchiveType.GZip)
{
if (transport.SourceIsDirectory)
{
return(StatusCode.InvalidArgumentStatus("Multiple files are not supported in this compression type", Config, ApplicationID));
}
}
if (archiveType != ArchiveType.Zip && string.IsNullOrEmpty(password) == false)
{
return(StatusCode.InvalidArgumentStatus("password is not supported on other than zip format", Config, ApplicationID));
}
string archiveFileDirectory = archiveInfo.Directory.FullName;
string archiveName = archiveInfo.Name;
System.IO.Directory.CreateDirectory(transport.DestinationFolderName);
switch (archiveType)
{
case ArchiveType.Zip:
transport.SourceFolderName = archiveFileDirectory;
transport.SourceFileName = archiveName;
Common.Archive.ZipArchive.Unzip(transport);
break;
case ArchiveType.BZip2:
transport.SourceFolderName = archiveFileDirectory;
transport.SourceFileName = archiveName;
Common.Archive.BZip2Archive.Extract(transport);
break;
case ArchiveType.GZip:
transport.SourceFolderName = archiveFileDirectory;
transport.SourceFileName = archiveName;
Common.Archive.GZipArchive.Extract(transport);
break;
case ArchiveType.Tar:
transport.SourceFolderName = archiveFileDirectory;
transport.SourceFileName = archiveName;
Common.Archive.TarArchive.Extract(transport);
break;
case ArchiveType.TGZ:
transport.SourceFolderName = archiveFileDirectory;
transport.SourceFileName = archiveName;
string originalDestinationFolder = transport.DestinationFolderName;
string originalDestinationFile = transport.DestinationFileName;
transport.DestinationFolderName = Path.GetTempPath();
transport.DestinationFileName = archiveName.Substring(0, archiveName.Length - (archiveInfo.Extension.Length)) + ".tar";
Common.Archive.GZipArchive.Extract(transport);
Models.FileTransportInfo tarInfo = new Models.FileTransportInfo(null, transport.DestinationFolderName, transport.DestinationFileName, originalDestinationFolder, originalDestinationFile);
Common.Archive.TarArchive.Extract(tarInfo);
File.Delete(transport.DestinationFullName);
break;
}
return(StatusCode.SUCCEED_STATUS);
}
public static StatusCode Archive(string archiveFilename, ArchiveType archiveType, List <Models.FileTransportInfo> SourceFiles, Common.Configurator Config, short ApplicationID, string password = null)
{
if (SourceFiles == null || SourceFiles.Count == 0)
{
return(StatusCode.InvalidArgumentStatus("Source File Not Specified to archive", Config, ApplicationID));
}
FileInfo archiveInfo = new System.IO.FileInfo(archiveFilename);
if (archiveType == ArchiveType.GuessFromFileName)
{
switch (archiveInfo.Extension.ToUpper())
{
case ".ZIP":
archiveType = ArchiveType.Zip;
break;
case ".TGZ":
archiveType = ArchiveType.TGZ;
break;
case ".BZ2":
archiveType = ArchiveType.BZip2;
break;
case ".GZ":
archiveType = ArchiveType.GZip;
break;
case ".TAR":
archiveType = ArchiveType.Tar;
break;
default:
return(StatusCode.InvalidArgumentStatus("File Extension Not supported for archiving", Config, ApplicationID));
}
}
if (archiveType == ArchiveType.BZip2 || archiveType == ArchiveType.GZip)
{
if (SourceFiles.Count > 1 || SourceFiles.Where(f => f.SourceIsDirectory).Count() > 0)
{
return(StatusCode.InvalidArgumentStatus("Multiple files are not supported in this compression type", Config, ApplicationID));
}
}
if (archiveType != ArchiveType.Zip && string.IsNullOrEmpty(password) == false)
{
return(StatusCode.InvalidArgumentStatus("password is not supported on other than zip format", Config, ApplicationID));
}
Models.FileTransportInfo transport = SourceFiles[0];
string archiveFileDirectory = archiveInfo.Directory.FullName;
string archiveName = archiveInfo.Name;
switch (archiveType)
{
case ArchiveType.Zip:
Common.Archive.ZipArchive.Create(archiveFilename, SourceFiles, password);
break;
case ArchiveType.BZip2:
transport.DestinationFolderName = archiveFileDirectory;
transport.DestinationFileName = archiveName;
Common.Archive.BZip2Archive.Create(transport);
break;
case ArchiveType.GZip:
transport.DestinationFolderName = archiveFileDirectory;
transport.DestinationFileName = archiveName;
Common.Archive.GZipArchive.Create(transport);
break;
case ArchiveType.Tar:
transport.DestinationFolderName = archiveFileDirectory;
transport.DestinationFileName = archiveName;
Common.Archive.TarArchive.Create(transport);
break;
case ArchiveType.TGZ:
transport.DestinationFolderName = Path.GetTempPath();
transport.DestinationFileName = archiveName.Substring(0, archiveName.Length - (archiveInfo.Extension.Length)) + ".tar";
Common.Archive.TarArchive.Create(transport);
Models.FileTransportInfo tgzInfo = new Models.FileTransportInfo(null, transport.DestinationFolderName, transport.DestinationFileName, archiveFileDirectory, archiveName);
Common.Archive.GZipArchive.Create(tgzInfo);
break;
}
return(StatusCode.SUCCEED_STATUS);
}
private static Common.Tasks.AbstractBaseTask CreateInstance(string assembly_name, string full_name, Common.Configurator config)
{
Common.Tasks.AbstractBaseTask abstractTask = null;
try
{
Type found_type = null;
Assembly found_assembly = null;
if (string.IsNullOrEmpty(assembly_name) == false)
{
try
{
found_assembly = AppDomain.CurrentDomain.Load(assembly_name);
}
catch (Exception) { }
}
if (found_assembly == null)
{
foreach (Assembly assembly in AppDomain.CurrentDomain.GetAssemblies())
{
found_assembly = assembly;
found_type = assembly.GetType(full_name);
if (found_type != null)
{
break;
}
}
}
abstractTask = (Common.Tasks.AbstractBaseTask)found_assembly.CreateInstance(full_name);
}
catch (Exception)
{
return(null);
}
if (abstractTask != null)
{
abstractTask.Config = config;
}
return(abstractTask);
}
public static Common.Tasks.AbstractBaseTask CreateNewTask(string assembly_name, string full_name, Common.Configurator config)
{
return(CreateInstance(assembly_name, full_name, config));
}
internal static Common.Tasks.AbstractBaseTask CreateNewTask(Models.TaskInfo taskInfo, Common.Configurator config)
{
return(CreateInstance(taskInfo.assembly_name, taskInfo.class_name, config));
}
