public void SecureStringToProtectedData()
{
AdapterRegistry.RegisterAdapter(
BackblazeB2Adapter.TargetTypeId,
typeof(BackblazeB2Adapter),
typeof(BackblazeB2AdapterConfiguration));
BackblazeB2AdapterConfiguration config = new BackblazeB2AdapterConfiguration();
config.AccountId = "1234";
config.ApplicationKey = new SecureString();
config.ApplicationKey.AppendChar('a');
config.ApplicationKey.AppendChar('b');
config.ApplicationKey.AppendChar('c');
config.ApplicationKey.AppendChar('1');
config.ApplicationKey.AppendChar('2');
config.ApplicationKey.AppendChar('3');
string s1 = JsonConvert.SerializeObject(config);
BackblazeB2AdapterConfiguration config2 =
JsonConvert.DeserializeObject <BackblazeB2AdapterConfiguration>(s1);
Assert.IsNotNull(config2);
Assert.IsNotNull(config2.ApplicationKey);
Assert.AreEqual(6, config2.ApplicationKey.Length);
Assert.AreEqual("abc123", config2.ApplicationKey.GetDecrytped());
}
private static void SetToken(Dictionary <string, string> args)
{
Global.Initialize(false);
AdapterBase adapter = GetAdapter(args);
string file;
if (!args.TryGetValue("file", out file))
{
throw new Exception("/file is required");
}
if (adapter.Configuration.AdapterTypeId == OneDriveAdapter.TargetTypeId)
{
string tokenContent = File.ReadAllText(file);
TokenResponse token = JsonConvert.DeserializeObject <TokenResponse>(tokenContent);
// Encrypt the token if not already encrypted
token.Protect();
((OneDriveAdapterConfiguration)adapter.Configuration).CurrentToken = token;
adapter.SaveConfiguration();
}
else
{
AdapterRegistration registration =
AdapterRegistry.GetRegistrationByTypeId(adapter.Configuration.AdapterTypeId);
throw new Exception(
string.Format("Cannot set token from adapter with type {0} ({1})",
registration.AdapterType.Name, adapter.Configuration.AdapterTypeId));
}
}
public static void ClassInitialize(TestContext testContext)
{
if (!GlobalTestSettings.RunNetworkTests)
{
return;
}
AdapterRegistry.RegisterAdapter(
AzureStorageAdapter.TargetTypeId,
typeof(AzureStorageAdapter),
typeof(AzureStorageAdapterConfiguration));
string accountInfoFilePath = Path.Combine(
Environment.GetFolderPath(Environment.SpecialFolder.DesktopDirectory),
"SyncProTesting",
"AzureStorageAccountInfo.json");
if (File.Exists(accountInfoFilePath))
{
string fileContent = File.ReadAllText(accountInfoFilePath);
accountInfo = JsonConvert.DeserializeObject <AzureStorageAdapterConfiguration>(fileContent);
return;
}
CredentialResult credentials;
try
{
credentials = CredentialHelper.PromptForCredentials(
"Enter your storage account name (username) and account key (password)");
}
catch (Win32Exception win32Exception)
when(win32Exception.NativeErrorCode ==
(int)NativeMethods.CredUI.CredUIReturnCodes.ERROR_CANCELLED)
{
Assert.Inconclusive("Azure storage credentials are required to run tests");
// ReSharper disable once HeuristicUnreachableCode
return;
}
accountInfo = new AzureStorageAdapterConfiguration
{
AccountName = credentials.Username,
AccountKey = credentials.Password,
ContainerName = DefaultContainerName
};
string serializedInfo = JsonConvert.SerializeObject(accountInfo, Formatting.Indented);
File.WriteAllText(accountInfoFilePath, serializedInfo);
}
private static void DumpConfig()
{
Global.Initialize(false);
string localAppDataPath = Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData);
string appDataRoot = Path.Combine(localAppDataPath, "SyncPro");
DirectoryInfo appDataRootDir = new DirectoryInfo(appDataRoot);
foreach (DirectoryInfo relationshipDir in appDataRootDir.GetDirectories())
{
Guid guid;
if (!Guid.TryParse(relationshipDir.Name, out guid))
{
WriteWarning("Failed to parse relationship directory '{0}' as a GUID", relationshipDir.Name);
continue;
}
SyncRelationship relationship = SyncRelationship.Load(guid);
//relationship.BeginInitialize();
// TODO: Do we really need to initialize the relationship in order to dump the configuration?
//relationship.InitializeAsync().Wait();
Console.WriteLine("---------------------------- [Relationship] ----------------------------");
Console.WriteLine("RelationshipId: " + relationship.Configuration.RelationshipId);
Console.WriteLine("Name: " + relationship.Configuration.Name);
Console.WriteLine("Description: " + relationship.Configuration.Description);
Console.WriteLine("Scope: " + relationship.Configuration.Scope);
Console.WriteLine("SyncAttributes: " + relationship.Configuration.SyncAttributes);
Console.WriteLine("TriggerType: " + relationship.Configuration.TriggerConfiguration.TriggerType);
Console.WriteLine("SourceAdapter: " + relationship.Configuration.SourceAdapterId);
Console.WriteLine("DestinationAdapter: " + relationship.Configuration.DestinationAdapterId);
Console.WriteLine();
Console.WriteLine("---------- [Adapters] ---------- ");
foreach (AdapterBase adapter in relationship.Adapters)
{
Console.WriteLine("Id: " + adapter.Configuration.Id);
Console.WriteLine("AdapterTypeId: " + adapter.Configuration.AdapterTypeId);
Console.WriteLine("AdapterTypeName: " +
AdapterRegistry.GetRegistrationByTypeId(adapter.Configuration.AdapterTypeId).AdapterType.Name);
Console.WriteLine("IsOriginator: " + adapter.Configuration.IsOriginator);
Console.WriteLine("Flags: " +
string.Join(",", StringExtensions.GetSetFlagNames <Data.AdapterFlags>(adapter.Configuration.Flags)));
Console.WriteLine();
}
Console.WriteLine();
}
}
public static SyncRelationship Load(Guid relationshipId)
{
string relationshipDir = Path.Combine(Global.AppDataRoot, relationshipId.ToString("N"));
RelationshipConfiguration config = RelationshipConfiguration.Load(relationshipDir);
Logger.RelationshipLoaded(
config.RelationshipId,
new Dictionary <string, object>()
{
{ "Name", config.Name },
{ "RelationshipId", config.RelationshipId },
{ "InitiallyCreatedUtc", config.InitiallyCreatedUtc },
{ "Scope", config.Scope }
});
SyncRelationship relationship = new SyncRelationship(config);
// Get the adapters from the configuration for this relationship
foreach (AdapterConfiguration adapterConfig in config.Adapters)
{
// Get the adapter registration information for this type of adapter
AdapterRegistration registration =
AdapterRegistry.GetRegistrationByTypeId(adapterConfig.AdapterTypeId);
if (registration == null)
{
throw new Exception("No adapter registration found with TypeId " + adapterConfig.AdapterTypeId);
}
// Create the adapter object based on its config from the database
AdapterBase adapter = (AdapterBase)Activator.CreateInstance(
registration.AdapterType,
relationship,
adapterConfig);
relationship.Adapters.Add(adapter);
// Load adapter-specific configuration settings
adapter.LoadConfiguration();
}
return(relationship);
}
private static void ExtractToken(Dictionary <string, string> args)
{
Global.Initialize(false);
AdapterBase adapter = GetAdapter(args);
bool formatToken = args.ContainsKey("formatToken");
string file;
args.TryGetValue("file", out file);
if (adapter.Configuration.AdapterTypeId == OneDriveAdapter.TargetTypeId)
{
TokenResponse token = ((OneDriveAdapterConfiguration)adapter.Configuration).CurrentToken;
if (args.ContainsKey("decrypt"))
{
token.Unprotect();
}
string formattedToken = JsonConvert.SerializeObject(token, formatToken ? Formatting.Indented : Formatting.None);
if (string.IsNullOrEmpty(file))
{
Console.WriteLine(formattedToken);
}
else
{
File.WriteAllText(file, formattedToken);
}
}
else
{
AdapterRegistration registration =
AdapterRegistry.GetRegistrationByTypeId(adapter.Configuration.AdapterTypeId);
throw new Exception(
string.Format("Cannot extract token from adapter with type {0} ({1})",
registration.AdapterType.Name, adapter.Configuration.AdapterTypeId));
}
}
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
{
JObject jObject = JObject.Load(reader);
Guid typeId = Guid.Parse(jObject["AdapterTypeId"].Value <string>());
//if (typeId == OneDriveAdapter.TargetTypeId)
//{
// return JsonConvert.DeserializeObject<OneDriveAdapterConfiguration>(
// jObject.ToString(),
// SerializerSettings);
//}
//if (typeId == WindowsFileSystemAdapter.TargetTypeId)
//{
// return JsonConvert.DeserializeObject<WindowsFileSystemAdapterConfiguration>(
// jObject.ToString(),
// SerializerSettings);
//}
//if (typeId == BackblazeB2Adapter.TargetTypeId)
//{
// return JsonConvert.DeserializeObject<BackblazeB2AdapterConfiguration>(
// jObject.ToString(),
// SerializerSettings);
//}
AdapterRegistration registration = AdapterRegistry.GetRegistrationByTypeId(typeId);
if (registration == null)
{
throw new Exception("No adapter registration found with TypeId " + typeId);
}
return(JsonConvert.DeserializeObject(
jObject.ToString(),
registration.AdapterConfigurationType,
SerializerSettings));
//throw new NotImplementedException("Cannot read adapter configuration for type ID " + typeId);
}
