public virtual void Initializa(long local_player_pstid, CombatStartInfo combat_start_info)
{
//真正的local_player_pstid在局外，传进来就好；combat_start_info是给所有玩家、观战者、以及录像回放时，都一致的消息
m_local_player_pstid = local_player_pstid;
m_level_data = GetConfigProvider().GetLevelData(combat_start_info.m_level_id);
m_state = CombatClientState.Loading;
m_state_frame_cnt = 0;
m_state_start_time = -1;
m_last_update_time = -1;
m_waiting_cnt = 0;
#if UNITY_EDITOR
m_is_first_frame = true;
#endif
AttributeSystem.Instance.InitializeAllDefinition(m_combat_factory.GetConfigProvider());
ComponentTypeRegistry.RegisterDefaultComponents();
BehaviorTreeNodeTypeRegistry.RegisterDefaultNodes();
DamageModifier.RegisterDefaultModifiers();
m_combat_factory.RegisterCommands();
BehaviorTreeFactory.Instance.SetConfigProvider(m_combat_factory.GetConfigProvider());
m_logic_world = m_combat_factory.CreateLogicWorld();
m_logic_world.Initialize(this, combat_start_info.m_world_seed, true);
m_render_world = m_combat_factory.CreateRenderWorld();
m_render_world.Initialize(this, m_logic_world);
m_logic_world.SetIRenderWorld(m_render_world);
m_sync_client = m_combat_factory.CreateSyncClient();
m_sync_client.Init(m_logic_world);
BuildLogicWorld(combat_start_info);
BuildRenderWorld(m_level_data);
}
private async void SyncBtnOnClick(object sender, EventArgs e)
{
_syncBtn.Enabled = false;
try
{
if (FileSyncApp.Instance.ActiveClients.ContainsKey(_folderId))
{
throw new Exception("WTF, sync in progress");
}
_client = SyncClientFactory.GetTwoWay(Common.Extensions.ParseEndpoint(_serverUrl), _folderItem.LocalPath, null, FileSyncApp.Instance.Config.ClientId, _folderItem.Id);
FileSyncApp.Instance.ActiveClients[_folderId] = _client; // TODO
_client.Log += AppendLog;
await Task.Run(_client.Sync);
FileSyncApp.Instance.ActiveClients.Remove(_folderId);
_client.Log -= AppendLog;
_client = null;
}
finally
{
_syncBtn.Enabled = true;
_client = null;
}
}
static Code1AddressVerificationService()
{
var environment = ConfigurationManager.AppSettings["NetTax.Environment"];
if (string.IsNullOrEmpty(environment))
environment = ConfigurationManager.AppSettings["Environment"];
var region = ConfigurationManager.AppSettings["NetTax.Region"];
if (string.IsNullOrEmpty(region))
region = ConfigurationManager.AppSettings["Region"];
var endpoint = EndpointsConfig
.FromContractAssembly<ICode1Service>()
.ForEnvironment(environment)
.ForRegion(region)
.WithParameters(key =>
{
if (key.Equals("Region"))
return region;
return ConfigurationManager.AppSettings[key];
})
.ForContract<ICode1Service>()
.NamedEndpoint("Code1Service");
_client = SyncClient<ICode1Service>.Create(endpoint);
}
private void PrepareServerClient()
{
_testServerConfig = new TestServerConfig();
_testServerConfig.Clients.Add(new RegisteredClient
{
Id = Guid.Empty,
FolderEndpoints =
{
new ClientFolderEndpoint
{
Id = Guid.Empty,
DisplayName = "folder1",
LocalPath = _serverFolder,
}
}
});
SessionStorage.Instance.SetTimeout(0);
_server = new SyncServer(ServerPort, Guid.Empty, _testServerConfig);
_server.Msg += ServerWrite;
_server.Start();
var serverEp = new IPEndPoint(IPAddress.Parse("127.0.0.1"), ServerPort);
_client = SyncClientFactory.GetTwoWay(serverEp, _clientFolder, null, Guid.Empty, Guid.Empty);
_client.Log += ClientWrite;
_client.ErrorEvent += ClientOnErrorEvent;
}
internal WebServiceClient(
int accountId,
string licenseKey,
IEnumerable <string>?locales,
string host,
int timeout,
HttpMessageHandler?httpMessageHandler,
// This is a hack so that we can keep this internal while adding
// httpMessageHandler to the public constructor. We can remove
// this when we drop .NET 4.5 support and get rid of ISyncClient.
bool fakeParam = false
#if !NETSTANDARD1_4
, ISyncClient?syncWebRequest = null
#endif
, HttpClient?httpClient = null
)
{
var auth = EncodedAuth(accountId, licenseKey);
_host = host;
_locales = locales == null ? new List <string> {
"en"
} : new List <string>(locales);
#if !NETSTANDARD1_4
_syncClient = syncWebRequest ?? new SyncClient(auth, timeout, UserAgent);
#endif
_asyncClient = new AsyncClient(auth, timeout, UserAgent, httpMessageHandler, httpClient);
}
public void Destruct()
{
m_sync_client.Destruct();
m_sync_client = null;
m_render_world.Destruct();
m_render_world = null;
m_logic_world.Destruct();
m_logic_world = null;
}
/// <summary>
/// Uploads the given ISync Element using the ISyncClient
/// If success the Element will be added or an existing element will be updated with
/// the new values
/// </summary>
/// <param name="element"></param>
/// <param name="client"></param>
/// <param name="indexManager"></param>
private void Upload(CancellationToken cancleToken, ISyncElement element, ISyncClient client, SyncIndexManager indexManager)
{
IRemoteProperty uploaded = element.Upload(cancleToken, client);
if (uploaded != null)
{
//Upload was successfull, add as tracked element to index
indexManager.AddOrUpdate(CreateIndexElement(element, uploaded));
}
}
internal MensaClient(ISyncClient syncClient)
{
if (syncClient != null)
{
this._syncClient = syncClient;
}
else
{
this._syncClient = new MensaKLSyncClient();
}
}
public FileUploadWorker(ISyncClient syncClient, string sourceDirectory,
Func <string, bool> validateFile,
Action <string, object[]> log,
Action <Exception> logError)
{
this.syncClient = syncClient;
this.sourceDirectory = sourceDirectory;
this.validateFile = validateFile;
this.log = log;
this.logError = logError;
}
public static void PushChanges(ISyncClient client, ISyncServer server)
{
while(true)
{
var entity = client.GetChangedOnClient();
if (entity == null)
break;
var server_sync_date = server.SendChangedToServer(entity);
client.SetClientEntitySynced(entity, server_sync_date);
}
}
public virtual void Destruct()
{
m_sync_client.Destruct();
m_sync_client = null;
m_render_world.Destruct();
m_render_world = null;
m_logic_world.Destruct();
m_logic_world = null;
m_combat_factory = null;
m_level_data = null;
}
private static void PullChanges(ISyncClient client, ISyncServer server)
{
var date = client.GetMaxServerSyncDate();
while(true)
{
var proxy = server.GetChangedFromServer(date);
if (proxy == null)
break;
client.ApplyChangeFromServer(proxy);
date = proxy.ServerSyncDate;
}
}
public void Initializa(long local_player_pstid)
{
m_local_player_pstid = local_player_pstid;
m_state = TestCombatClientState.Loading;
m_waiting_cnt = 0;
m_logic_world = new TestLogicWorld(this, true);
m_render_world = new TestRenderWorld(this, m_logic_world);
m_sync_client = new MNLPSyncClient();
m_sync_client.Init(m_logic_world);
++m_waiting_cnt;
m_render_world.LoadScene();
}
public static void PushChanges(ISyncClient client, ISyncServer server)
{
while (true)
{
var entity = client.GetChangedOnClient();
if (entity == null)
{
break;
}
var server_sync_date = server.SendChangedToServer(entity);
client.SetClientEntitySynced(entity, server_sync_date);
}
}
/// <summary>
/// Uploads the File of the FileSync element ot the
/// Server using the provided ISync Client and returns the created or updated
/// IRemote Property
/// </summary>
/// <param name="client"></param>
/// <returns></returns>
public IRemoteProperty Upload(CancellationToken cancleToken, ISyncClient client)
{
try
{
using (FileStream stream = _info.OpenRead())
{
return(client.PutFile(cancleToken, _relativePath, stream));
}
} catch (Exception exc)
{
_logger.Error("Error occured while uploading file " + RelativePath, exc);
return(null);
}
}
public CloudClient(ISyncClient client, int millisecondsTimeout, int maxBufferLength)
{
SyncWaitDic = new ConcurrentDictionary <long, ReturnEventWaitHandle>(10, 10000);
AsyncCallDiy = new ConcurrentDictionary <long, AsyncCalls>();
CallBackDiy = new ConcurrentDictionary <long, AsyncCalls>();
AsyncRunDiy = new ConcurrentDictionary <long, AsyncRun>();
Client = client;
MillisecondsTimeout = millisecondsTimeout;
RingBuffer = new ZYNetRingBufferPool(maxBufferLength);
Sync = new ZYSync();
Sync.SyncSend = SendData;
Sync.SyncSendAsWait = SendDataAsWait;
Module = new ModuleDictionary();
}
private static void PullChanges(ISyncClient client, ISyncServer server)
{
var date = client.GetMaxServerSyncDate();
while (true)
{
var proxy = server.GetChangedFromServer(date);
if (proxy == null)
{
break;
}
client.ApplyChangeFromServer(proxy);
date = proxy.ServerSyncDate;
}
}
/// <summary>
/// Downloads the File from the ISync client and
/// patches the current local file with the downloaded version
/// or creates new file
/// </summary>
/// <returns>An IFileInfo property continaing information about the overwritten File, or null if download failed</returns>
public FileInfo PatchLocalFile(CancellationToken cancleToken, ISyncClient client)
{
//Get Temp File from Remote
_logger.Debug("Patching " + _relativePath + " with version from server");
FileInfo tempFile = client.DownloadRemoteFileToTemp(cancleToken, _relativePath.UrlDecode());
if (tempFile != null)
{
if (cancleToken.IsCancellationRequested)
{
return(null);
}
_info = FileManager.CopyFile(tempFile.FullName, _rootDirPath + _relativePath, true, _logger);
return(_info);
}
return(null);
}
internal WebServiceClient(
int accountId,
string licenseKey,
IEnumerable <string>?locales,
string host,
int timeout,
HttpClient httpClient,
ISyncClient?syncWebRequest = null
)
{
var auth = EncodedAuth(accountId, licenseKey);
_host = host;
_locales = (locales == null ? new List <string> {
"en"
} : new List <string>(locales)).AsReadOnly();
_syncClient = syncWebRequest ?? new SyncClient(auth, timeout, UserAgent);
_asyncClient = new AsyncClient(auth, timeout, UserAgent, httpClient);
}
protected override void OnCreate(Bundle savedInstanceState)
{
base.OnCreate(savedInstanceState);
SetContentView(Resource.Layout.FolderView);
Window.AddFlags(WindowManagerFlags.KeepScreenOn);
_serverUrl = Intent.GetStringExtra("server");
_serverItem = FileSyncApp.Instance.Config.Servers.Single(x => x.Url == _serverUrl);
_folderId = Guid.ParseExact(Intent.GetStringExtra("folderId"), "D");
_folderItem = _serverItem.Folders.Single(x => x.Id == _folderId);
FindViewById <TextView>(Resource.Id.folderViewNameView).Text = _folderItem.DisplayName;
FindViewById <TextView>(Resource.Id.folderViewPathView).Text = _folderItem.LocalPath;
_logTxtView = FindViewById <TextView>(Resource.Id.folderViewLogTxtView);
_logTxtView.MovementMethod = new ScrollingMovementMethod();
_syncBtn = FindViewById <Button>(Resource.Id.folderViewStartSyncBtn);
_syncBtn.Click += SyncBtnOnClick;
var btn = FindViewById <Button>(Resource.Id.folderViewDeleteFolderBtn);
btn.Click += DeleteFolderBtn_Click;
if (FileSyncApp.Instance.ActiveClients.TryGetValue(_folderId, out var client))
{
_syncBtn.Enabled = false;
_client = client;
_client.Log += AppendLog;
_client.SyncTask.ContinueWith(x =>
{
RunOnUiThread(() => { _syncBtn.Enabled = true; });
FileSyncApp.Instance.ActiveClients.Remove(_folderId);
_client.Log -= AppendLog;
_client = null;
});
}
}
internal WebServiceClient(
int userId,
string licenseKey,
IEnumerable <string> locales,
string host = "geoip.maxmind.com",
int timeout = 3000,
HttpMessageHandler httpMessageHandler = null
#if !NETSTANDARD1_4
, ISyncClient syncWebRequest = null
#endif
)
{
var auth = EncodedAuth(userId, licenseKey);
_host = host;
_locales = new List <string>(locales);
#if !NETSTANDARD1_4
_syncClient = syncWebRequest ?? new SyncClient(auth, timeout, UserAgent);
#endif
_asyncClient = new AsyncClient(auth, timeout, UserAgent, httpMessageHandler);
}
internal WebServiceClient(
int accountId,
string licenseKey,
IEnumerable <string> locales,
string host,
int timeout,
HttpMessageHandler httpMessageHandler
#if !NETSTANDARD1_4
, ISyncClient syncWebRequest = null
#endif
)
{
var auth = EncodedAuth(accountId, licenseKey);
_host = host;
_locales = locales == null ? new List <string> {
"en"
} : new List <string>(locales);
#if !NETSTANDARD1_4
_syncClient = syncWebRequest ?? new SyncClient(auth, timeout, UserAgent);
#endif
_asyncClient = new AsyncClient(auth, timeout, UserAgent, httpMessageHandler);
}
public async Task StartAsync(CancellationToken cancellationToken)
{
_logger.LogInformation("Starting synchronizer service...");
if (_syncClient == null && _clientScope == null)
{
_clientScope = _dependencyScope.BeginLifetimeScope(
containerConfig => _syncClientFactory.ConfigureContainerBuilder(containerConfig));
// The scope is disposed right after creation of the sync client. This should not be a problem as
// the client holds references to all required instances after creation.
_syncClient = _syncClientFactory.CreateSyncClient(_clientScope);
var authenticator = _clientScope.Resolve <ISmintIoAuthenticator>();
Debug.Assert(authenticator != null, nameof(authenticator) + " != null");
// we have a system browser based authenticator here, which will work synchronously
await authenticator.InitializeAuthenticationAsync();
}
await _syncClient.StartAsync(cancellationToken);
_logger.LogInformation("Started synchronizer service");
}
protected virtual void InitClientTwo()
{
clientManifestTwo = new SyncManifest ();
clientStorageTwo = new DiskStorage ();
clientStorageTwo.SetPath (clientStorageDirTwo);
clientEngineTwo = new Engine (clientStorageTwo);
syncClientTwo = new FilesystemSyncClient (clientEngineTwo, clientManifestTwo);
}
/// <summary>
/// Iterates trough all Index Elements and checks wheter the still exist
/// If not they have been deleted locally and will be removed on the server
/// </summary>
/// <param name="dto"></param>
/// <param name="client"></param>
/// <param name="logger"></param>
/// <param name="indexManager"></param>
private void DetectLocalDeletedElements(CancellationToken cancleToken, Configuration dto, ISyncClient client, ILogger logger, SyncIndexManager indexManager)
{
IEnumerable <SyncIndexElementDTO> indexElements = indexManager.GetOrCreateIndexFile();
List <SyncIndexElementDTO> removeElements = new List <SyncIndexElementDTO>();
foreach (SyncIndexElementDTO element in indexElements)
{
if (cancleToken.IsCancellationRequested)
{
return;
}
bool exists = true;
string absolutePath = dto.Local.LocalSyncDir + element.ReleativeFilePath;
try
{
if (element.ElementType.Equals(SyncElementType.File))
{
exists = File.Exists(absolutePath);
}
else if (element.ElementType.Equals(SyncElementType.Directory))
{
exists = Directory.Exists(absolutePath);
}
} catch (Exception exc) { _logger.Error("Error occured while checking " + element.ElementType + "existance: ", exc); }
if (!exists)
{
_logger.Debug(element.ElementType + " " + element.ReleativeFilePath + " does not exist anymore. Will be deleted from server and index.");
removeElements.Add(element);
}
}
//Get List of Directories that are contained in the removeElements list
List <SyncIndexElementDTO> directories = removeElements.Where(x => x.ElementType == SyncElementType.Directory).ToList();
foreach (SyncIndexElementDTO element in directories)
{
//remove all Elements that are contained in removeElements list and
//are part of this Directory
removeElements.RemoveAll(x => x.ReleativeFilePath.Length > element.ReleativeFilePath.Length &&
x.ReleativeFilePath.Substring(0, element.ReleativeFilePath.Length) == element.ReleativeFilePath);
}
//Remove all elements that can be removed
foreach (SyncIndexElementDTO element in removeElements)
{
if (client.Remove(cancleToken, element.ReleativeFilePath))
{
//If its a Directory delete all Elements that are contained in this Directory
//From the index!
if (element.ElementType == SyncElementType.Directory)
{
indexManager.RemoveAll(x => x.ReleativeFilePath.Length >= element.ReleativeFilePath.Length &&
x.ReleativeFilePath.Substring(0, element.ReleativeFilePath.Length) == element.ReleativeFilePath);
}
else
{
indexManager.Remove(element);
}
}
}
}
/// <summary>
/// Downloaded the given RemotePropery and adds it as a local file
/// </summary>
/// <param name="remoteProperty"></param>
/// <param name="client"></param>
/// <param name="conf"></param>
/// <param name="logger"></param>
/// <param name="indexManager"></param>
private void FetchFileFromServer(CancellationToken cancleToken, IRemoteProperty remoteProperty, ISyncClient client, Configuration conf, ILogger logger, SyncIndexManager indexManager)
{
try
{
string localFilePath = conf.Local.LocalSyncDir + remoteProperty.DecodedRelativeRemotePath;
if (!File.Exists(localFilePath))
{
//File does not exist local, will be downloaded and added
_logger.Debug(remoteProperty.DecodedRelativeRemotePath + " does not exist locally. Will be downloaded and added to index");
FileInfo temp = client.DownloadRemoteFileToTemp(cancleToken, remoteProperty.DecodedRelativeRemotePath);
if (temp != null)
{
FileInfo newFile = FileManager.CopyFile(temp.FullName, localFilePath, true, _logger);
if (newFile != null)
{
FileSyncElement newFileElement = new FileSyncElement(newFile, conf.Local.LocalSyncDir, logger);
indexManager.AddOrUpdate(CreateIndexElement(newFileElement, remoteProperty));
}
}
}
} catch (Exception exc)
{
logger.Error("Unexpected error while fetching " + remoteProperty.RelativeRemotePath + " from server: ", exc);
}
}
/// <summary>
/// Checks for the given elements children or remote updates, has the option to only check the children and ignore updates in case
/// Can be usefull to give the server enough time to index new files
/// </summary>
/// <param name="cancleToken"></param>
/// <param name="element"></param>
/// <param name="client"></param>
/// <param name="properties"></param>
/// <param name="indexManager"></param>
/// <param name="logger"></param>
/// <param name="config"></param>
/// <param name="ignoreUpdates"></param>
private void HandleISyncElementChildrenOrUpdates(CancellationToken cancleToken, ISyncElement element, ISyncClient client,
IEnumerable <IRemoteProperty> properties, SyncIndexManager indexManager, ILogger logger,
Configuration config, bool ignoreUpdates)
{
//File: check for updates
//Directoy: process with going one hierarchy deeper
if (element.Type.Equals(SyncElementType.File))
{
if (!ignoreUpdates)
{
CheckForFileUpdates(cancleToken, (FileSyncElement)element, client, properties, indexManager);
}
}
else if (element.Type.Equals(SyncElementType.Directory))
{
GetDataAndHandleSync(cancleToken, element.AbsolutePath, client, logger, config, indexManager);
}
else
{
throw new NotImplementedException();
}
}
/// <summary>
/// Handles the synchronisation of the given ISyncElement
/// </summary>
/// <param name="element"></param>
/// <param name="client"></param>
/// <param name="properties"></param>
/// <param name="indexManager"></param>
private void HandleISyncElement(CancellationToken cancleToken, ISyncElement element, ISyncClient client, IEnumerable <IRemoteProperty> properties,
SyncIndexManager indexManager, ILogger logger, Configuration config)
{
if (cancleToken.IsCancellationRequested)
{
return;
}
//The general rules defining when to synchronize what are the same
//for all ISyncClients and they follow the following design:
//
//1. Iterate all local folder and their files, check for updates on server:
// Both:
// 1. when it does not exist in index and server -> upload
// 2. when it exists only in index -> delete (has been deleted remotely)
// 3. when exists on server but not index -> update index
// Files:
// 1. When is exists in server and index -> check for updates
//2. Add all files that are not in index to local copy
//3. Remove all files that exist in index and server but not local from server -> deleted local
(bool existInIndex, bool existsRemote)existance = CheckForElementExistance(element, properties, indexManager);
if (!existance.existInIndex && !existance.existsRemote)
{
//Not in index and not in remote -> upload
logger.Debug(element.Type + " " + element.RelativePath + " does not exist in local Index and remote, " +
"File will be added to both");
Upload(cancleToken, element, client, indexManager);
//Set the Method to ignore Updates -> Just handle children in case of Directory
//Because directly checking for updates may cause exceptions because the server is
//slow and does not return the correct properties on request yet
HandleISyncElementChildrenOrUpdates(cancleToken, element, client, properties, indexManager, logger, config, true);
}
else if (existance.existInIndex && !existance.existsRemote)
{
//In index but not remote -> delete (has been deleted remotely)
logger.Debug(element.Type + " " + element.RelativePath + " exists in index but has been removed remote. Deleting " + element.Type);
DeleteLocalElement(element, indexManager);
}
else if (!existance.existInIndex && existance.existsRemote)
{
//Remote but not in index -> Add to index
logger.Debug(element.Type + " " + element.RelativePath + " was missing in the index -> will be added.");
//As it cannot be said if there was changes remote, no remote revision is added
indexManager.AddOrUpdate(CreateIndexElement(element, null));
HandleISyncElementChildrenOrUpdates(cancleToken, element, client, properties, indexManager, logger, config, false);
}
else if (existance.existInIndex && existance.existsRemote)
{
HandleISyncElementChildrenOrUpdates(cancleToken, element, client, properties, indexManager, logger, config, false);
}
}
/// <summary>
/// Gets all Files and Directories at the given Path and handles their synchronisation
/// </summary>
/// <param name="absolutePath"></param>
private void GetDataAndHandleSync(CancellationToken cancleToken, string absolutePath, ISyncClient client,
ILogger logger, Configuration config, SyncIndexManager indexManager)
{
//Get the remote Properties, Files and Folder of the root folder
IEnumerable <IRemoteProperty> remoteProperties = client.GetProperties(GetRemotePath(config, absolutePath));
IEnumerable <FileSyncElement> files = GetFiles(absolutePath, config, logger);
IEnumerable <DirectorySyncElement> directories = GetDirectories(absolutePath, config, logger);
//If there is no connection or something went wrong during request
if (remoteProperties == null)
{
_logger.Error("Something went wrong during connection to server.");
return;
}
//First the Directories -> ensure they are not deleted before processing everything else
foreach (DirectorySyncElement dir in directories)
{
if (cancleToken.IsCancellationRequested)
{
return;
}
HandleISyncElement(cancleToken, dir, client, remoteProperties, indexManager, logger, config);
}
foreach (FileSyncElement file in files)
{
if (cancleToken.IsCancellationRequested)
{
return;
}
HandleISyncElement(cancleToken, file, client, remoteProperties, indexManager, logger, config);
}
}
/// <summary>
/// Checks wheter
/// </summary>
/// <param name="file"></param>
/// <param name="client"></param>
/// <param name="properties"></param>
/// <param name="indexManager"></param>
private void CheckForFileUpdates(CancellationToken cancleToken, FileSyncElement file, ISyncClient client, IEnumerable <IRemoteProperty> properties, SyncIndexManager indexManager)
{
//Get Index and property instances
SyncIndexElementDTO index = GetIndexElement(indexManager, file);
IRemoteProperty property = GetProperty(properties, file);
//Compare the change dates
if (!index.LocalRevision.Equals(file.Revision) && index.RemoteRevision.Equals(property.RemoteRevision))
{
//File has been changed locally
_logger.Debug("File " + file.RelativePath + " has been changed locally. Index rev: " + index.LocalRevision + " current file rev: " + file.Revision);
Upload(cancleToken, file, client, indexManager);
}
else if (index.LocalRevision.Equals(file.Revision) && !index.RemoteRevision.Equals(property.RemoteRevision))
{
//File has been changed remotely
_logger.Debug("File " + file.RelativePath + " has been changed remotely. Index remote rev: " + index.RemoteRevision + " current remote rev: " + property.RemoteRevision);
PatchLocalFile(cancleToken, file, client, indexManager, properties);
}
else if (!index.LocalRevision.Equals(file.Revision) && !index.RemoteRevision.Equals(property.RemoteRevision))
{
//Conflict! Remote and server version has been changed!
//Priorise server version, patch Local file
_logger.Debug("File " + file.RelativePath + " has been changed remote and locally. Will fetch server version over local version");
_logger.Debug("File " + file.RelativePath + " local index local rev: " + index.LocalRevision + " file local rev: " + file.Revision);
_logger.Debug("File " + file.RelativePath + " remote index rev: " + index.RemoteRevision + " file remote rev: " + property.RemoteRevision);
PatchLocalFile(cancleToken, file, client, indexManager, properties);
}
}
/// <summary>
/// Patches the local file with the current File version provided by the ISyncClient
/// </summary>
/// <param name="file"></param>
/// <param name="client"></param>
/// <param name="indexManager"></param>
private void PatchLocalFile(CancellationToken cancleToken, FileSyncElement file, ISyncClient client, SyncIndexManager indexManager,
IEnumerable <IRemoteProperty> remoteProperties)
{
//File has been changed remotely
FileInfo update = file.PatchLocalFile(cancleToken, client);
if (update != null)
{
//Updte Index Manager
indexManager.AddOrUpdate(CreateIndexElement(file, GetProperty(remoteProperties, file)));
}
}
/// <summary>
/// Creates a Remote Directory at the relative Path of the dir and returns
/// the Createes IRemoteProperty
/// </summary>
/// <param name="client"></param>
/// <returns></returns>
public IRemoteProperty Upload(CancellationToken cancleToken, ISyncClient client)
{
return(client.CreateDirectory(cancleToken, _relativePath));
}
public SyncManager(ISyncClient client, ISyncServer server)
{
this.client = client;
this.server = server;
}
/// <summary>
/// Executes the synchronisation for the given configuration and using the
/// given Client
/// This Method can be called multiple times using different configurations or client
/// to achive different synchronisations
/// </summary>
public void ExcecuteSynchronisation(CancellationToken cancleToken, Configuration config, ISyncClient client)
{
_logger.Debug("Executing synchronisation for Directory " + config.Local.LocalSyncDir + " using client of type " + client.GetType());
//Check if default dir extists, else delete
if (!Directory.Exists(config.Local.LocalSyncDir))
{
_logger.Debug("Creating sync directory at " + config.Local.LocalSyncDir);
Directory.CreateDirectory(config.Local.LocalSyncDir);
}
//Read or create the index File
_logger.Debug("Reading index File");
SyncIndexManager indexManager = new SyncIndexManager(_logger, config);
//The following three steps are performed for a synchronisation:
//1. Iterate all local folder and their files, check for updates on server
//2. Remove all files that exist in index and server but not local from server -> deleted local
//3. Add all files that are not in index to local copy
//Start getting Files at the root Folder
GetDataAndHandleSync(cancleToken, config.Local.LocalSyncDir, client, _logger, config, indexManager);
if (cancleToken.IsCancellationRequested)
{
return;
}
DetectLocalDeletedElements(cancleToken, config, client, _logger, indexManager);
if (cancleToken.IsCancellationRequested)
{
return;
}
FetchNewFilesFromServer(cancleToken, config, client, _logger, indexManager);
_logger.Debug("Synchronisation finished");
}
// forces re-readin from disk, and will make sure a client does not hold
// Notes which are equal by reference as the server when using FilesystemSync
protected void ClearClientOne(bool reset = false)
{
if (reset) {
clientManifestOne = new SyncManifest ();
CleanupClientDirectoryOne ();
}
clientStorageOne = new DiskStorage ();
clientStorageOne.SetPath (clientStorageDirOne);
clientEngineOne = new Engine (clientStorageOne);
syncClientOne = new FilesystemSyncClient (clientEngineOne, clientManifestOne);
}
public static void PullAndPushChanges(ISyncClient client, ISyncServer server)
{
PullChanges(client, server);
PushChanges(client, server);
}
protected void ClearClientTwo(bool reset = false)
{
if (reset) {
clientManifestTwo = new SyncManifest ();
CleanupClientDirectoryTwo ();
}
clientStorageTwo = new DiskStorage ();
clientStorageTwo.SetPath (clientStorageDirTwo);
clientEngineTwo = new Engine (clientStorageTwo);
syncClientTwo = new FilesystemSyncClient (clientEngineTwo, clientManifestTwo);
}
protected virtual void InitClientOne()
{
clientStorageOne = new DiskStorage ();
clientStorageOne.SetPath (clientStorageDirOne);
clientEngineOne = new Engine (clientStorageOne);
clientManifestOne = new SyncManifest ();
syncClientOne = new FilesystemSyncClient (clientEngineOne, clientManifestOne);
}
public static void PullAndPushChanges(ISyncClient client, ISyncServer server)
{
PullChanges(client, server);
PushChanges(client, server);
}
