/// <summary>
/// Sets up a fetcher that can get remote CMIS folders.
/// </summary>
public Fetcher(RepoInfo repoInfo, IActivityListener activityListener)
{
string remote_path = repoInfo.RemotePath.Trim("/".ToCharArray());
string address = repoInfo.Address.ToString();
TargetFolder = repoInfo.TargetDirectory;
RemoteUrl = new Uri(address + remote_path);
Logger.Info("Fetcher | Cmis Fetcher constructor");
TargetFolder = repoInfo.TargetDirectory;
RemoteUrl = repoInfo.Address;
// Check that the CmisSync root folder exists.
if (!Directory.Exists(ConfigManager.CurrentConfig.FoldersPath))
{
Logger.Fatal(String.Format("Fetcher | ERROR - Cmis Default Folder {0} does not exist", ConfigManager.CurrentConfig.FoldersPath));
throw new DirectoryNotFoundException("Root folder don't exist !");
}
// Check that the folder is writable.
if (!Utils.HasWritePermissionOnDir(ConfigManager.CurrentConfig.FoldersPath))
{
Logger.Fatal(String.Format("Fetcher | ERROR - Cmis Default Folder {0} is not writable", ConfigManager.CurrentConfig.FoldersPath));
throw new UnauthorizedAccessException("Root folder is not writable!");
}
// Check that the folder exists.
if (Directory.Exists(repoInfo.TargetDirectory))
{
Logger.Fatal(String.Format("Fetcher | ERROR - Cmis Repository Folder {0} already exist", repoInfo.TargetDirectory));
throw new UnauthorizedAccessException("Repository folder already exists!");
}
// Create the local folder.
Directory.CreateDirectory(repoInfo.TargetDirectory);
// Use this folder configuration.
this.cmisRepo = new CmisRepo(repoInfo, activityListener);
}
/// <summary>
/// Check whether the file is worth syncing or not.
/// This optionally excludes blank files or files too large.
/// </summary>
private static bool IsFileWorthSyncing(string filepath, RepoInfo repoInfo)
{
if (File.Exists(filepath))
{
bool allowBlankFiles = true; //TODO: add a preference repoInfo.allowBlankFiles
bool limitFilesize = false; //TODO: add preference for filesize limiting
long filesizeLimit = 256 * 1024 * 1024; //TODO: add a preference for filesize limit
FileInfo fileInfo = new FileInfo(filepath);
//Check permissions
if (fileInfo.Attributes.HasFlag(FileAttributes.Hidden))
{
Logger.DebugFormat("Skipping {0}: hidden file", filepath);
return false;
}
if (fileInfo.Attributes.HasFlag(FileAttributes.System))
{
Logger.DebugFormat("Skipping {0}: system file", filepath);
return false;
}
//Check filesize
if (!allowBlankFiles && fileInfo.Length <= 0)
{
Logger.DebugFormat("Skipping {0}: blank file", filepath);
return false;
}
if (limitFilesize && fileInfo.Length > filesizeLimit)
{
Logger.DebugFormat("Skipping {0}: file too large {1}mb", filepath, fileInfo.Length / (1024f * 1024f));
return false;
}
}
else if (Directory.Exists(filepath))
{
return IsDirectoryWorthSyncing(filepath, repoInfo);
}
return true;
}
/// <summary>
/// Get all the configured info about a synchronized folder.
/// </summary>
public RepoInfo GetRepoInfo(string folderName)
{
RepoInfo repoInfo = new RepoInfo(folderName, ConfigPath);
repoInfo.User = GetFolderAttribute(folderName, "user");
repoInfo.Password = GetFolderAttribute(folderName, "password");
repoInfo.Address = GetUrlForFolder(folderName);
repoInfo.RepoID = GetFolderAttribute(folderName, "repository");
repoInfo.RemotePath = GetFolderAttribute(folderName, "remoteFolder");
repoInfo.TargetDirectory = GetFolderAttribute(folderName, "path");
double pollinterval = 0;
double.TryParse(GetFolderAttribute(folderName, "pollinterval"), out pollinterval);
if (pollinterval < 1) pollinterval = 5000;
repoInfo.PollInterval = pollinterval;
if (String.IsNullOrEmpty(repoInfo.TargetDirectory))
{
repoInfo.TargetDirectory = Path.Combine(FoldersPath, folderName);
}
LinkedList<string> ignoredFolders = getIgnoredFolders(folderName);
foreach (string ignoredFolder in ignoredFolders)
{
repoInfo.addIgnorePath(ignoredFolder);
}
return repoInfo;
}
/// <summary>
/// Constructor.
/// </summary>
public RepoBase(RepoInfo repoInfo, IActivityListener activityListener)
{
EventManager = new SyncEventManager();
EventManager.AddEventHandler(new DebugLoggingHandler());
EventManager.AddEventHandler(new GenericSyncEventHandler<RepoConfigChangedEvent>(0, RepoInfoChanged));
Queue = new SyncEventQueue(EventManager);
RepoInfo = repoInfo;
LocalPath = repoInfo.TargetDirectory;
Name = repoInfo.Name;
RemoteUrl = repoInfo.Address;
this.activityListener = activityListener;
if (repoInfo.IsSuspended) Status = SyncStatus.Suspend;
// Folder lock.
// Disabled for now. Can be an interesting feature, but should be made opt-in, as
// most users would be surprised to see this file appear.
// folderLock = new FolderLock(LocalPath);
Watcher = new Watcher(LocalPath);
Watcher.EnableRaisingEvents = true;
// Main loop syncing every X seconds.
remote_timer.Elapsed += delegate
{
// Synchronize.
SyncInBackground();
};
remote_timer.AutoReset = true;
Logger.Info("Repo " + repoInfo.Name + " - Set poll interval to " + repoInfo.PollInterval + "ms");
remote_timer.Interval = repoInfo.PollInterval;
//Partial sync interval..
local_timer.Elapsed += delegate
{
// Run partial sync.
SyncInBackground(false);
};
local_timer.AutoReset = false;
local_timer.Interval = delay_interval;
}
/// <summary>
/// Initialize (in the GUI and syncing mechanism) an existing CmisSync synchronized folder.
/// </summary>
/// <param name="repositoryInfo">Synchronized folder path</param>
private void AddRepository(RepoInfo repositoryInfo)
{
RepoBase repo = null;
repo = new CmisSync.Lib.Sync.CmisRepo(repositoryInfo, activityListenerAggregator);
this.repositories.Add(repo);
repo.Initialize();
}
public void SyncWhileModifyingFolders(string canonical_name, string localPath, string remoteFolderPath,
string url, string user, string password, string repositoryId)
{
// Prepare checkout directory.
string localDirectory = Path.Combine(CMISSYNCDIR, canonical_name);
CleanDirectory(localDirectory);
Console.WriteLine("Synced to clean state.");
// Mock.
IActivityListener activityListener = new Mock<IActivityListener>().Object;
// Sync.
RepoInfo repoInfo = new RepoInfo(
canonical_name,
CMISSYNCDIR,
remoteFolderPath,
url,
user,
password,
repositoryId,
5000);
using (CmisRepo cmis = new CmisRepo(repoInfo, activityListener))
{
using (CmisRepo.SynchronizedFolder synchronizedFolder = new CmisRepo.SynchronizedFolder(
repoInfo,
activityListener,
cmis))
{
synchronizedFolder.Sync();
Console.WriteLine("Synced to clean state.");
// Sync a few times in a different thread.
bool syncing = true;
BackgroundWorker bw = new BackgroundWorker();
bw.DoWork += new DoWorkEventHandler(
delegate(Object o, DoWorkEventArgs args)
{
for (int i = 0; i < 10; i++)
{
Console.WriteLine("Sync D" + i.ToString());
synchronizedFolder.Sync();
}
}
);
bw.RunWorkerCompleted += new RunWorkerCompletedEventHandler(
delegate(object o, RunWorkerCompletedEventArgs args)
{
syncing = false;
}
);
bw.RunWorkerAsync();
// Keep creating/removing a file as long as sync is going on.
while (syncing)
{
//Console.WriteLine("Create/remove.");
LocalFilesystemActivityGenerator.CreateDirectoriesAndFiles(localDirectory);
CleanAll(localDirectory);
}
// Clean.
Console.WriteLine("Clean all.");
Clean(localDirectory, synchronizedFolder);
}
}
}
public void ClientSideBigFileAddition(string canonical_name, string localPath, string remoteFolderPath,
string url, string user, string password, string repositoryId)
{
// Prepare checkout directory.
string localDirectory = Path.Combine(CMISSYNCDIR, canonical_name);
CleanDirectory(localDirectory);
Console.WriteLine("Synced to clean state.");
IActivityListener activityListener = new Mock<IActivityListener>().Object;
RepoInfo repoInfo = new RepoInfo(
canonical_name,
".",
remoteFolderPath,
url,
user,
password,
repositoryId,
5000);
using (CmisRepo cmis = new CmisRepo(repoInfo, activityListener))
{
using (CmisRepo.SynchronizedFolder synchronizedFolder = new CmisRepo.SynchronizedFolder(
repoInfo,
activityListener,
cmis))
{
synchronizedFolder.Sync();
Console.WriteLine("Synced to clean state.");
// Create random big file.
LocalFilesystemActivityGenerator.CreateRandomFile(localDirectory, 1000); // 1 MB ... no that big to not load servers too much.
// Sync again.
synchronizedFolder.Sync();
Console.WriteLine("Second sync done.");
// Check that file is present server-side.
// TODO
// Clean.
Console.WriteLine("Clean all.");
Clean(localDirectory, synchronizedFolder);
}
}
}
/// <summary>
/// Get all the configured info about a synchronized folder.
/// </summary>
public RepoInfo GetRepoInfo()
{
RepoInfo repoInfo = new RepoInfo(DisplayName, ConfigManager.CurrentConfig.ConfigPath);
repoInfo.User = UserName;
repoInfo.Password = new CmisSync.Auth.CmisPassword();
repoInfo.Password.ObfuscatedPassword = ObfuscatedPassword;
repoInfo.Address = RemoteUrl;
repoInfo.RepoID = RepositoryId;
repoInfo.RemotePath = RemotePath;
repoInfo.TargetDirectory = LocalPath;
if (PollInterval < 1) PollInterval = Config.DEFAULT_POLL_INTERVAL;
repoInfo.PollInterval = PollInterval;
foreach (IgnoredFolder ignoredFolder in IgnoredFolders)
{
repoInfo.addIgnorePath(ignoredFolder.Path);
}
return repoInfo;
}
/// <summary></summary>
/// <param name="path"></param>
/// <param name="repoInfo"></param>
/// <returns></returns>
public static SyncItem CreateFromRemotePath(string path, RepoInfo repoInfo)
{
return new RemotePathSyncItem(path, repoInfo);
}
/// <summary>
/// Constructor.
/// </summary>
public RepoBase(RepoInfo repoInfo)
{
RepoInfo = repoInfo;
LocalPath = repoInfo.TargetDirectory;
Name = repoInfo.Name;
RemoteUrl = repoInfo.Address;
Logger.Info("Repo " + repoInfo.Name + " - Set poll interval to " + repoInfo.PollInterval + "ms");
this.remote_timer.Interval = repoInfo.PollInterval;
SyncStatusChanged += delegate(SyncStatus status)
{
Status = status;
};
this.Watcher = new Watcher(LocalPath);
// Main loop syncing every X seconds.
this.remote_timer.Elapsed += delegate
{
// Synchronize.
SyncInBackground();
};
ChangesDetected += delegate { };
}
public RemotePathSyncItem(string remoteFolderPath, string remoteDocumentName, string localFilename, bool isFolder, RepoInfo repoInfo, Database.Database database)
{
this.isFolder = isFolder;
this.database = database;
this.localRoot = repoInfo.TargetDirectory;
this.remoteRoot = repoInfo.RemotePath;
this.remoteRelativePath = remoteFolderPath;
if (remoteRelativePath.StartsWith(this.remoteRoot))
{
this.remoteRelativePath = remoteRelativePath.Substring(this.remoteRoot.Length).TrimStart(CmisUtils.CMIS_FILE_SEPARATOR);
}
this.localRelativePath = localFilename;
}
/// <summary>
/// Create from the path of a remote file, and the local filename to use.
/// </summary>
/// <param name="remoteRelativePath">Example: adir/a<file</param>
/// <param name="localFilename">Example: afile.txt</param>
public RemotePathSyncItem(string remoteRelativePath, string localFilename, RepoInfo repoInfo, Database.Database database)
{
this.isFolder = false;
this.database = database;
this.localRoot = repoInfo.TargetDirectory;
this.remoteRoot = repoInfo.RemotePath;
this.remoteRelativePath = remoteRelativePath;
if (remoteRelativePath.StartsWith(this.remoteRoot))
{
this.remoteRelativePath = this.remoteRelativePath.Substring(localRoot.Length).TrimStart(CmisUtils.CMIS_FILE_SEPARATOR);
}
int lastSeparator = remoteRelativePath.LastIndexOf(CmisUtils.CMIS_FILE_SEPARATOR);
string remoteRelativeFolder = lastSeparator >= 0 ?
remoteRelativePath.Substring(0, lastSeparator)
: String.Empty;
string remoteRelativePathWithCorrectLeafname = CmisUtils.PathCombine(remoteRelativeFolder, localFilename);
localRelativePath = database.RemoteToLocal(remoteRelativePathWithCorrectLeafname, isFolder);
}
public LocalPathSyncItem(string localPath, bool isFolder, RepoInfo repoInfo, Database.Database database)
{
this.isFolder = isFolder;
this.database = database;
this.localRoot = repoInfo.TargetDirectory;
this.remoteRoot = repoInfo.RemotePath;
this.localRelativePath = localPath;
if (localPath.StartsWith(this.localRoot))
{
this.localRelativePath = localPath.Substring(localRoot.Length).TrimStart(Path.DirectorySeparatorChar);
}
}
/// <summary>
/// Create sync item from the path of a remote folder.
/// </summary>
/// <param name="remoteFolderPath">Example: /sites/aproject/adir</param>
public static SyncItem CreateFromRemoteFolder(string remoteFolderPath, RepoInfo repoInfo, Database.Database database)
{
return new RemotePathSyncItem(remoteFolderPath, true, repoInfo, database);
}
/// <summary></summary>
/// <param name="localFolder"></param>
/// <param name="remoteFileName"></param>
/// <param name="repoInfo"></param>
/// <returns></returns>
public static SyncItem CreateFromLocalFolderAndRemoteName(string localFolder, string remoteFileName, RepoInfo repoInfo)
{
return new LocalPathSyncItem(localFolder, remoteFileName, repoInfo);
}
/// <summary>
/// Add a synchronized folder to the configuration.
/// </summary>
public void AddFolder(RepoInfo repoInfo)
{
if (null == repoInfo)
{
return;
}
SyncConfig.Folder folder = new SyncConfig.Folder() {
DisplayName = repoInfo.Name,
LocalPath = repoInfo.TargetDirectory,
IgnoredFolders = new List<IgnoredFolder>(),
RemoteUrl = repoInfo.Address,
RepositoryId = repoInfo.RepoID,
RemotePath = repoInfo.RemotePath,
UserName = repoInfo.User,
ObfuscatedPassword = repoInfo.Password.ObfuscatedPassword,
PollInterval = repoInfo.PollInterval
};
foreach (string ignoredFolder in repoInfo.getIgnoredPaths())
{
folder.IgnoredFolders.Add(new IgnoredFolder(){Path = ignoredFolder});
}
this.configXml.Folders.Add(folder);
Save();
}
/// <summary></summary>
/// <param name="remoteFolder"></param>
/// <param name="LocalFileName"></param>
/// <param name="repoInfo"></param>
/// <returns></returns>
public static SyncItem CreateFromRemoteFolderAndLocalName(string remoteFolder, string LocalFileName, RepoInfo repoInfo)
{
return new RemotePathSyncItem(remoteFolder, LocalFileName, repoInfo);
}
public void Sync(string canonical_name, string localPath, string remoteFolderPath,
string url, string user, string password, string repositoryId)
{
// Prepare checkout directory.
string localDirectory = Path.Combine(CMISSYNCDIR, canonical_name);
CleanDirectory(localDirectory);
Console.WriteLine("Synced to clean state.");
IActivityListener activityListener = new Mock<IActivityListener>().Object;
RepoInfo repoInfo = new RepoInfo(
canonical_name,
CMISSYNCDIR,
remoteFolderPath,
url,
user,
password,
repositoryId,
5000);
using (CmisRepo cmis = new CmisRepo(repoInfo, activityListener))
{
using (CmisRepo.SynchronizedFolder synchronizedFolder = new CmisRepo.SynchronizedFolder(
repoInfo,
activityListener,
cmis))
{
synchronizedFolder.Sync();
Console.WriteLine("Synced to clean state.");
// Clean.
Console.WriteLine("Clean all.");
Clean(localDirectory, synchronizedFolder);
}
}
}
/// <summary></summary>
/// <param name="localPath"></param>
/// <param name="repoInfo"></param>
public LocalPathSyncItem(string localPath, RepoInfo repoInfo)
{
this.localRoot = repoInfo.TargetDirectory;
this.remoteRoot = repoInfo.RemotePath;
this.localPath = localPath;
if (localPath.StartsWith(this.localRoot))
{
this.localPath = localPath.Substring(localRoot.Length).TrimStart(Path.DirectorySeparatorChar);
}
this.remotePath = PathRepresentationConverter.LocalToRemote(this.localPath);
}
public void ClientSideDirectoryAndSmallFilesAddition(string canonical_name, string localPath, string remoteFolderPath,
string url, string user, string password, string repositoryId)
{
// Prepare checkout directory.
string localDirectory = Path.Combine(CMISSYNCDIR, canonical_name);
CleanDirectory(localDirectory);
Console.WriteLine("Synced to clean state.");
IActivityListener activityListener = new Mock<IActivityListener>().Object;
RepoInfo repoInfo = new RepoInfo(
canonical_name,
CMISSYNCDIR,
remoteFolderPath,
url,
user,
password,
repositoryId,
5000);
using (CmisRepo cmis = new CmisRepo(repoInfo, activityListener))
{
using (CmisRepo.SynchronizedFolder synchronizedFolder = new CmisRepo.SynchronizedFolder(
repoInfo,
activityListener,
cmis))
{
synchronizedFolder.Sync();
Console.WriteLine("Synced to clean state.");
// Create directory and small files.
LocalFilesystemActivityGenerator.CreateDirectoriesAndFiles(localDirectory);
// Sync again.
synchronizedFolder.Sync();
Console.WriteLine("Second sync done.");
// Clean.
Console.WriteLine("Clean all.");
Clean(localDirectory, synchronizedFolder);
}
}
}
/// <summary></summary>
/// <param name="remotePath"></param>
/// <param name="repoInfo"></param>
public RemotePathSyncItem(string remotePath, RepoInfo repoInfo)
{
this.localRoot = repoInfo.TargetDirectory;
this.remoteRoot = PathRepresentationConverter.LocalToRemote(repoInfo.RemotePath);
this.remotePath = remotePath;
if (remotePath.StartsWith(this.remoteRoot))
{
this.remotePath = remotePath.Substring(this.remoteRoot.Length).TrimStart(CmisUtils.CMIS_FILE_SEPARATOR);
}
this.localPath = PathRepresentationConverter.RemoteToLocal(this.remotePath);
}
/// <summary>
/// Initialize (in the UI and syncing mechanism) an existing CmisSync synchronized folder.
/// </summary>
/// <param name="repositoryInfo">Synchronized folder path</param>
private void AddRepository(RepoInfo repositoryInfo)
{
RepoBase repo = null;
repo = new CmisSync.Lib.Sync.CmisRepo(repositoryInfo, activityListenerAggregator);
repo.EventManager.AddEventHandler(
new GenericSyncEventHandler<FileTransmissionEvent>( 50, delegate(ISyncEvent e){
this.activitiesManager.AddTransmission(e as FileTransmissionEvent);
return false;
}));
this.repositories.Add(repo);
repo.Initialize();
}
/// <summary></summary>
/// <param name="remoteFolder"></param>
/// <param name="localRelativePath"></param>
/// <param name="repoInfo"></param>
public RemotePathSyncItem(string remoteFolder, string localRelativePath, RepoInfo repoInfo)
{
this.localRoot = repoInfo.TargetDirectory;
this.remoteRoot = repoInfo.RemotePath;
this.remotePath = Path.Combine(remoteFolder, PathRepresentationConverter.LocalToRemote(localRelativePath));
if (this.remotePath.StartsWith(this.remoteRoot))
{
this.remotePath = this.remotePath.Substring(this.localRoot.Length).TrimStart(CmisUtils.CMIS_FILE_SEPARATOR);
}
string remoteRootRelative = remoteFolder;
if (remoteFolder.StartsWith(this.remoteRoot))
{
remoteRootRelative = remoteFolder.Substring(localRoot.Length).TrimStart(CmisUtils.CMIS_FILE_SEPARATOR);
}
this.localPath = Path.Combine(PathRepresentationConverter.RemoteToLocal(remoteRootRelative), localRelativePath);
}
/// <summary>
/// Create a new CmisSync synchronized folder.
/// </summary>
public void CreateRepository(string name, Uri address, string user, string password, string repository, string remote_path, string local_path,
List<string> ignoredPaths, bool syncAtStartup)
{
repoInfo = new RepoInfo(name, ConfigManager.CurrentConfig.ConfigPath);
repoInfo.Address = address;
repoInfo.User = user;
repoInfo.Password = new Password(password);
repoInfo.RepoID = repository;
repoInfo.RemotePath = remote_path;
repoInfo.TargetDirectory = local_path;
repoInfo.PollInterval = Config.DEFAULT_POLL_INTERVAL;
repoInfo.IsSuspended = false;
repoInfo.LastSuccessedSync = new DateTime(1900, 01, 01);
repoInfo.SyncAtStartup = syncAtStartup;
repoInfo.MaxUploadRetries = 2;
foreach (string ignore in ignoredPaths)
repoInfo.addIgnorePath(ignore);
// Check that the CmisSync root folder exists.
if (!Directory.Exists(ConfigManager.CurrentConfig.FoldersPath))
{
Logger.Fatal(String.Format("Fetcher | ERROR - Cmis Default Folder {0} does not exist", ConfigManager.CurrentConfig.FoldersPath));
throw new DirectoryNotFoundException("Root folder don't exist !");
}
// Check that the folder is writable.
if (!CmisSync.Lib.Utils.HasWritePermissionOnDir(ConfigManager.CurrentConfig.FoldersPath))
{
Logger.Fatal(String.Format("Fetcher | ERROR - Cmis Default Folder {0} is not writable", ConfigManager.CurrentConfig.FoldersPath));
throw new UnauthorizedAccessException("Root folder is not writable!");
}
// Check that the folder exists.
if (Directory.Exists(repoInfo.TargetDirectory))
{
Logger.Fatal(String.Format("Fetcher | ERROR - Cmis Repository Folder {0} already exist", repoInfo.TargetDirectory));
throw new UnauthorizedAccessException("Repository folder already exists!");
}
// Create the local folder.
Directory.CreateDirectory(repoInfo.TargetDirectory);
// Add folder to XML config file.
ConfigManager.CurrentConfig.AddFolder(repoInfo);
// Initialize in the GUI.
AddRepository(repoInfo);
FolderListChanged();
}
/// <summary></summary>
/// <param name="path"></param>
/// <param name="repoInfo"></param>
/// <returns></returns>
public static SyncItem CreateFromLocalPath(string path, RepoInfo repoInfo)
{
return new LocalPathSyncItem(path, repoInfo);
}
/// <summary>
/// Add a synchronized folder to the configuration.
/// </summary>
public void AddFolder(RepoInfo repoInfo)
{
if (null == repoInfo)
{
return;
}
this.AddFolder(repoInfo.Name, repoInfo.TargetDirectory, repoInfo.Address, repoInfo.RepoID, repoInfo.RemotePath, repoInfo.User, repoInfo.Password, repoInfo.PollInterval, repoInfo.getIgnoredPaths());
}
/// <summary></summary>
/// <param name="folder"></param>
/// <param name="fileName"></param>
/// <param name="repoInfo"></param>
/// <returns></returns>
public static SyncItem CreateFromLocalPath(string folder, string fileName, RepoInfo repoInfo)
{
return new LocalPathSyncItem(Path.Combine(folder, fileName), repoInfo);
}
/// <summary>
/// Check whether the directory is worth syncing or not.
/// Directories that are not worth syncing include ignored, system, and hidden folders.
/// </summary>
private static bool IsDirectoryWorthSyncing(string localDirectory, RepoInfo repoInfo)
{
if (!localDirectory.StartsWith(repoInfo.TargetDirectory))
{
Logger.WarnFormat("Local directory is outside repo target directory. local={0}, repo={1}", localDirectory, repoInfo.TargetDirectory);
return false;
}
//Check for ignored path...
string path = localDirectory.Substring(repoInfo.TargetDirectory.Length).Replace("\\", "/");
if (repoInfo.isPathIgnored(path))
{
Logger.DebugFormat("Skipping {0}: hidden folder", localDirectory);
return false;
}
//Check system/hidden
DirectoryInfo directoryInfo = new DirectoryInfo(localDirectory);
if (directoryInfo.Exists)
{
if (directoryInfo.Attributes.HasFlag(FileAttributes.Hidden))
{
Logger.DebugFormat("Skipping {0}: hidden folder", localDirectory);
return false;
}
if (directoryInfo.Attributes.HasFlag(FileAttributes.System))
{
Logger.DebugFormat("Skipping {0}: system folder", localDirectory);
return false;
}
}
return true;
}
/// <summary>
/// Get all the configured info about a synchronized folder.
/// </summary>
public RepoInfo GetRepoInfo()
{
// TODO: workaround
var localPath = LocalPath.TrimEnd(Path.DirectorySeparatorChar);
RepoInfo repoInfo = new RepoInfo(DisplayName, ConfigManager.CurrentConfig.ConfigPath);
repoInfo.User = UserName;
repoInfo.Password = new Password();
repoInfo.Password.ObfuscatedPassword = ObfuscatedPassword;
repoInfo.Address = RemoteUrl;
repoInfo.RepoID = RepositoryId;
repoInfo.RemotePath = RemotePath;
repoInfo.TargetDirectory = localPath;
repoInfo.MaxUploadRetries = uploadRetries;
repoInfo.MaxDownloadRetries = downloadRetries;
repoInfo.MaxDeletionRetries = deletionRetries;
if (PollInterval < 1) PollInterval = Config.DEFAULT_POLL_INTERVAL;
repoInfo.PollInterval = PollInterval;
repoInfo.IsSuspended = IsSuspended;
repoInfo.SyncAtStartup = SyncAtStartup;
foreach (IgnoredFolder ignoredFolder in IgnoredFolders)
{
repoInfo.addIgnorePath(ignoredFolder.Path);
}
if(SupportedFeatures != null && SupportedFeatures.ChunkedSupport != null && SupportedFeatures.ChunkedSupport == true)
{
repoInfo.ChunkSize = ChunkSize;
repoInfo.DownloadChunkSize = ChunkSize;
}
else
{
repoInfo.ChunkSize = 0;
repoInfo.DownloadChunkSize = 0;
}
if(SupportedFeatures != null && SupportedFeatures.ChunkedDownloadSupport!=null && SupportedFeatures.ChunkedDownloadSupport == true)
repoInfo.DownloadChunkSize = ChunkSize;
return repoInfo;
}
/// <summary>
/// Check whether the file is worth syncing or not.
/// Files that are not worth syncing include temp files, locks, etc.
/// </summary>
public static Boolean WorthSyncing(string localDirectory, string filename, RepoInfo repoInfo)
{
return IsFilenameWorthSyncing(localDirectory, filename) &&
IsDirectoryWorthSyncing(localDirectory, repoInfo) &&
IsFileWorthSyncing(Path.Combine(localDirectory, filename), repoInfo);
}
/// <summary>
/// Check whether the file is worth syncing or not.
/// Files that are not worth syncing include temp files, locks, etc.
/// </summary>
public static Boolean WorthSyncing(string localDirectory, string filename, RepoInfo repoInfo)
{
return(IsFilenameWorthSyncing(localDirectory, filename) &&
IsDirectoryWorthSyncing(localDirectory, repoInfo) &&
IsFileWorthSyncing(Path.Combine(localDirectory, filename), repoInfo));
}
