public async Task GetZones_ValidServer_ZonesReturned()
{
using (var udpClient = new UdpClient())
{
var networkClient = new UdpNetworkClient(udpClient);
var target = new DirectoryClient(networkClient, IPAddress.Parse("108.61.133.122"));
var actual = await target.GetZonesAsync();
Assert.AreNotEqual(0, actual.Count);
}
}
public async Task DownloadAsync()
{
// Create a temporary Lorem Ipsum file on disk that we can upload
string originalPath = CreateTempFile(SampleFileContent);
// Get a temporary path on disk where we can download the file
string downloadPath = CreateTempPath();
// Get a connection string to our Azure Storage account.
string connectionString = ConnectionString;
// Get a reference to a share named "sample-share" and then create it
ShareClient share = new ShareClient(connectionString, Randomize("sample-share"));
await share.CreateAsync();
try
{
// Get a reference to a directory named "sample-dir" and then create it
DirectoryClient directory = share.GetDirectoryClient(Randomize("sample-dir"));
await directory.CreateAsync();
// Get a reference to a file named "sample-file" in directory "sample-dir"
FileClient file = directory.GetFileClient(Randomize("sample-file"));
// Upload the file
using (FileStream stream = File.OpenRead(originalPath))
{
await file.CreateAsync(stream.Length);
await file.UploadRangeAsync(
FileRangeWriteType.Update,
new HttpRange(0, stream.Length),
stream);
}
// Download the file
StorageFileDownloadInfo download = await file.DownloadAsync();
using (FileStream stream = File.OpenWrite(downloadPath))
{
await download.Content.CopyToAsync(stream);
}
// Verify the contents
Assert.AreEqual(SampleFileContent, File.ReadAllText(downloadPath));
}
finally
{
// Clean up after the test when we're finished
await share.DeleteAsync();
}
}
public async Task GivenDirectoryEntry_WhenRoundTrip_Success()
{
DirectoryClient client = TestApplication.GetDirectoryClient();
var documentId = new DocumentId("test/unit-tests/entry1");
var query = new QueryParameter()
{
Filter = "test/unit-tests",
Recursive = false,
};
IReadOnlyList <DatalakePathItem> search = (await client.Search(query).ReadNext()).Records;
if (search.Any(x => x.Name == (string)documentId))
{
await client.Delete(documentId);
}
var entry = new DirectoryEntryBuilder()
.SetDirectoryId(documentId)
.SetClassType("test")
.AddProperty(new EntryProperty {
Name = "property1", Value = "value1"
})
.Build();
await client.Set(entry);
search = (await client.Search(query).ReadNext()).Records;
search.Any(x => x.Name == (string)documentId).Should().BeTrue();
DirectoryEntry?readEntry = await client.Get(documentId);
readEntry.Should().NotBeNull();
readEntry !.DirectoryId.Should().Be(entry.DirectoryId);
readEntry.ClassType.Should().Be(entry.ClassType);
readEntry.ETag.Should().NotBeNull();
readEntry.Properties.Count.Should().Be(1);
readEntry.Properties.Values.First().Action(x =>
{
(x == entry.Properties.Values.First()).Should().BeTrue();
});
await client.Delete(documentId);
search = (await client.Search(query).ReadNext()).Records;
search.Any(x => x.Name == (string)documentId).Should().BeFalse();
}
public async Task UploadAsync()
{
// Create a temporary Lorem Ipsum file on disk that we can upload
string path = CreateTempFile(SampleFileContent);
// Get a connection string to our Azure Storage account. You can
// obtain your connection string from the Azure Portal (click
// Access Keys under Settings in the Portal Storage account blade)
// or using the Azure CLI with:
//
// az storage account show-connection-string --name <account_name> --resource-group <resource_group>
//
// And you can provide the connection string to your application
// using an environment variable.
string connectionString = ConnectionString;
// Get a reference to a share named "sample-share" and then create it
ShareClient share = new ShareClient(connectionString, Randomize("sample-share"));
await share.CreateAsync();
try
{
// Get a reference to a directory named "sample-dir" and then create it
DirectoryClient directory = share.GetDirectoryClient(Randomize("sample-dir"));
await directory.CreateAsync();
// Get a reference to a file named "sample-file" in directory "sample-dir"
FileClient file = directory.GetFileClient(Randomize("sample-file"));
// Upload the file
using (FileStream stream = File.OpenRead(path))
{
await file.CreateAsync(stream.Length);
await file.UploadRangeAsync(
FileRangeWriteType.Update,
new HttpRange(0, stream.Length),
stream);
}
// Verify the file exists
StorageFileProperties properties = await file.GetPropertiesAsync();
Assert.AreEqual(SampleFileContent.Length, properties.ContentLength);
}
finally
{
// Clean up after the test when we're finished
await share.DeleteAsync();
}
}
/// <summary>
/// Called after a client gets the first packet of CS_ZoneList()
/// </summary>
/// <param name="pkt"></param>
/// <param name="client"></param>
public static void Handle_CS_AckZoneList(CS_AckZoneList pkt, DirectoryClient client)
{
//Update the zone list first..
//Program.server.grabZones();
List <SC_ZoneList> packets = Program.server.ZoneStream.Packets;
UInt16 frame = pkt.frameReceived;
// Can we send the next frame?
if (++frame < packets.Count)
{
client.send(packets[frame]);
}
}
/// <summary>
/// Called when a client clicks "Refresh Zone List"
/// </summary>
/// <param name="pkt"></param>
/// <param name="client"></param>
public static void Handle_CS_ZoneList(CS_ZoneList pkt, DirectoryClient client)
{
//Update the zone list first..
//Program.server.grabZones();
// Begin sending the zone list packets
client.ZoneListToken = pkt.Token;
// Send the first packet
List <SC_ZoneList> packets = Program.server.ZoneStream.Packets;
if (packets.Count != 0)
{
client.send(packets[0]);
}
}
public async Task DirectorySample()
{
// Instantiate a new FileServiceClient using a connection string.
FileServiceClient fileServiceClient = new FileServiceClient(TestConfigurations.DefaultTargetTenant.ConnectionString);
// Instantiate new ShareClient
ShareClient shareClient = fileServiceClient.GetShareClient($"myshare2-{Guid.NewGuid()}");
try
{
// Create Share in the Service
await shareClient.CreateAsync();
// Instantiate new DirectoryClient
DirectoryClient directoryClient = shareClient.GetDirectoryClient("mydirectory");
// Create Directory in the Service
await directoryClient.CreateAsync();
// Instantiate new DirectoryClient
DirectoryClient subDirectoryClient = directoryClient.GetSubdirectoryClient("mysubdirectory");
// Create sub directory
await subDirectoryClient.CreateAsync();
// List Files and Directories
await foreach (StorageFileItem item in directoryClient.GetFilesAndDirectoriesAsync())
{
var type = item.IsDirectory ? "dir" : "file";
Console.WriteLine($"{type}: {item.Name}");
}
// Delete sub directory in the Service
await subDirectoryClient.DeleteAsync();
// Delete Directory in the Service
await directoryClient.DeleteAsync();
}
finally
{
// Delete Share in the service
await shareClient.DeleteAsync();
}
}
private string InitialiseBuildRun(string sourcePath, string project)
{
var tasksDestinationPath = Path.Combine(ConfigurationManager.AppSettings["tasksRunnerRootPath"], project);
//root path for the source task artifacts
var tasksSourcePath = sourcePath;
//create new directory for tasks to run
if (!Directory.Exists(tasksDestinationPath))
{
Directory.CreateDirectory(tasksDestinationPath);
}
int latestCount = GetNextBuildNumber(tasksDestinationPath);
var runPath = Path.Combine(tasksDestinationPath, string.Format("{0}", latestCount));
Directory.CreateDirectory(runPath);
//generate basic log to identify task run
string path = Path.Combine(runPath, string.Format("{0}", WebConfigurationManager.AppSettings[BUILD_LOG_DATA_FILE]));
// This text is added only once to the file.
if (!System.IO.File.Exists(path))
{
// Create a file to write to.
using (StreamWriter sw = System.IO.File.CreateText(path))
{
sw.WriteLine(string.Format("{0} Ver: {1}", "Build Runner version", "2.1"));
sw.WriteLine(string.Format("{0} {1}", DateTime.UtcNow, runPath));
}
}
//copy all build version specific definition files to latest build running path
DirectoryClient.DirectoryCopy(tasksSourcePath, runPath, true);
FileClient.CreateZipFromDirectory(tasksSourcePath, Path.Combine(runPath, WebConfigurationManager.AppSettings[TASK_DEFINITIONS_ARCHIVE]));
return(runPath);
}
public async Task DirectorySample()
{
// Instantiate a new FileServiceClient using a connection string.
FileServiceClient fileServiceClient = new FileServiceClient(TestConfigurations.DefaultTargetTenant.ConnectionString);
// Instantiate new ShareClient
ShareClient shareClient = fileServiceClient.GetShareClient("myshare2");
try
{
// Create Share in the Service
await shareClient.CreateAsync();
// Instantiate new DirectoryClient
DirectoryClient directoryClient = shareClient.GetDirectoryClient("mydirectory");
// Create Directory in the Service
await directoryClient.CreateAsync();
// Instantiate new DirectoryClient
DirectoryClient subDirectoryClient = directoryClient.GetDirectoryClient("mysubdirectory");
// Create sub directory
await subDirectoryClient.CreateAsync();
// List Files and Directories
Response <FilesAndDirectoriesSegment> listResponse = await directoryClient.ListFilesAndDirectoriesSegmentAsync();
// Delete sub directory in the Service
await subDirectoryClient.DeleteAsync();
// Delete Directory in the Service
await directoryClient.DeleteAsync();
}
finally
{
// Delete Share in the service
await shareClient.DeleteAsync();
}
}
public static async Task <IServiceCollection> ConfigureContractService(this IServiceCollection service, ApplicationOption option)
{
service.VerifyNotNull(nameof(service));
ApplicationOption applicationOption = await DirectoryClient.Run(option.DirectoryUrl, option.DirectoryApiKey, async client =>
{
ServiceRecord contractRecord = await client.GetServiceRecord(option.RunEnvironment, "Contract");
ServiceRecord artifactRecord = await client.GetServiceRecord(option.RunEnvironment, "Artifact");
option = option with
{
HostUrl = contractRecord.HostUrl,
ApiKey = contractRecord.ApiKey,
ArtifactUrl = artifactRecord.HostUrl,
ArtifactApiKey = artifactRecord.ApiKey,
};
return(option.Verify());
});
service.AddSingleton(applicationOption);
service.AddSingleton <ContractService>();
service.AddHttpClient <SigningClient>((service, httpClient) =>
{
ApplicationOption option = service.GetRequiredService <ApplicationOption>();
httpClient.BaseAddress = new Uri(option.DirectoryUrl);
httpClient.DefaultRequestHeaders.Add(Constants.ApiKeyName, option.DirectoryApiKey);
});
service.AddHttpClient <ArtifactClient>((service, httpClient) =>
{
ApplicationOption option = service.GetRequiredService <ApplicationOption>();
httpClient.BaseAddress = new Uri(option.ArtifactUrl);
httpClient.DefaultRequestHeaders.Add(Constants.ApiKeyName, option.ArtifactApiKey);
});
return(service);
}
public static async Task <IServiceCollection> ConfigureArtifactService(this IServiceCollection service, ApplicationOption option)
{
service.VerifyNotNull(nameof(service));
ApplicationOption applicationOption = await DirectoryClient.Run <ApplicationOption>(option.DirectoryUrl, option.DirectoryApiKey, async client =>
{
ServiceRecord serviceRecord = await client.GetServiceRecord(option.RunEnvironment, "Artifact");
IReadOnlyList <StorageRecord> storageRecords = await client.GetStorageRecord(option.RunEnvironment, "Artifact");
return(option with
{
HostUrl = serviceRecord.HostUrl,
ApiKey = serviceRecord.ApiKey,
Storage = storageRecords,
});
});
service.AddSingleton <IDocumentPackage, DocumentPackage>();
service.AddSingleton(applicationOption);
service.AddSingleton <DocumentPackageFactory>(service =>
{
ApplicationOption option = service.GetRequiredService <ApplicationOption>();
ILoggerFactory loggerFactory = service.GetRequiredService <ILoggerFactory>();
var list = option.Storage
.Select(x => (Container: x.Container, Option: new DatalakeStoreOption
{
AccountName = x.AccountName,
ContainerName = x.ContainerName,
AccountKey = x.AccountKey,
BasePath = x.BasePath
}));
return(new DocumentPackageFactory(list, loggerFactory));
});
return(service);
}
private string InitialiseBuildRun()
{
var tasksDestinationPath = ConfigurationManager.AppSettings["tasksRunnerRootPath"];
//root path for the source task artifacts
var tasksSourcePath = ConfigurationManager.AppSettings["tasksSourcePath"];
//create new directory for tasks to run
if (!Directory.Exists(tasksDestinationPath))
{
Directory.CreateDirectory(tasksDestinationPath);
}
int latestCount = GetNextBuildNumber(tasksDestinationPath);
var runPath = Path.Combine(tasksDestinationPath, string.Format("{0}", latestCount));
Directory.CreateDirectory(runPath);
//generate basic log to identify task run
string path = Path.Combine(runPath, string.Format("{0}", "build.log"));
// This text is added only once to the file.
if (!File.Exists(path))
{
// Create a file to write to.
using (StreamWriter sw = File.CreateText(path))
{
sw.WriteLine(string.Format("{0} Ver: {1}", "Build Runner version", "2.1"));
sw.WriteLine(string.Format("{0} {1}", DateTime.UtcNow, runPath));
}
}
//copy build artifacts
DirectoryClient.DirectoryCopy(tasksSourcePath, runPath, true);
return(runPath);
}
public static async Task <DisposingDirectory> CreateAsync(DisposingShare test, DirectoryClient directory)
{
await directory.CreateAsync();
return(new DisposingDirectory(test, directory));
}
public ListActivity(DirectoryClient directoryClient, ILogger <ListActivity> logger)
{
_directoryClient = directoryClient;
_logger = logger;
}
public async Task TraverseAsync()
{
// Create a temporary Lorem Ipsum file on disk that we can upload
string originalPath = CreateTempFile(SampleFileContent);
// Get a connection string to our Azure Storage account.
string connectionString = ConnectionString;
// Get a reference to a share named "sample-share" and then create it
ShareClient share = new ShareClient(connectionString, Randomize("sample-share"));
await share.CreateAsync();
try
{
// Create a bunch of directories
DirectoryClient first = await share.CreateDirectoryAsync("first");
await first.CreateSubdirectoryAsync("a");
await first.CreateSubdirectoryAsync("b");
DirectoryClient second = await share.CreateDirectoryAsync("second");
await second.CreateSubdirectoryAsync("c");
await second.CreateSubdirectoryAsync("d");
await share.CreateDirectoryAsync("third");
DirectoryClient fourth = await share.CreateDirectoryAsync("fourth");
DirectoryClient deepest = await fourth.CreateSubdirectoryAsync("e");
// Upload a file named "file"
FileClient file = deepest.GetFileClient("file");
using (FileStream stream = File.OpenRead(originalPath))
{
await file.CreateAsync(stream.Length);
await file.UploadRangeAsync(
FileRangeWriteType.Update,
new HttpRange(0, stream.Length),
stream);
}
// Keep track of all the names we encounter
List <string> names = new List <string>();
// Track the remaining directories to walk, starting from the root
Queue <DirectoryClient> remaining = new Queue <DirectoryClient>();
remaining.Enqueue(share.GetRootDirectoryClient());
while (remaining.Count > 0)
{
// Get all of the next directory's files and subdirectories
DirectoryClient dir = remaining.Dequeue();
await foreach (StorageFileItem item in dir.GetFilesAndDirectoriesAsync())
{
// Track the name of the item
names.Add(item.Name);
// Keep walking down directories
if (item.IsDirectory)
{
remaining.Enqueue(dir.GetSubdirectoryClient(item.Name));
}
}
}
// Verify we've seen everything
Assert.AreEqual(10, names.Count);
Assert.Contains("first", names);
Assert.Contains("second", names);
Assert.Contains("third", names);
Assert.Contains("fourth", names);
Assert.Contains("a", names);
Assert.Contains("b", names);
Assert.Contains("c", names);
Assert.Contains("d", names);
Assert.Contains("e", names);
Assert.Contains("file", names);
}
finally
{
// Clean up after the test when we're finished
await share.DeleteAsync();
}
}
public SetActivity(DirectoryClient directoryClient, IdentityClient identityClient, ILogger <SetActivity> logger)
{
_directoryClient = directoryClient;
_identityClient = identityClient;
_logger = logger;
}
public IDisposable GetNewDirectory(out DirectoryClient directory, FileServiceClient service = default)
{
var disposingShare = this.GetNewShare(out var share, default, service);
public IDisposable GetNewDirectory(out DirectoryClient directory, FileServiceClient service = default)
{
IDisposable disposingShare = GetNewShare(out ShareClient share, default, service);
public DeleteActivity(DirectoryClient directoryClient, ILogger <DeleteActivity> logger)
{
_directoryClient = directoryClient;
_logger = logger;
}
private DisposingDirectory(DisposingShare test, DirectoryClient directory)
{
_test = test;
Directory = directory;
}
