private bool UploadFiles(BllFilepathLib lib)
{
string foldername = Event.Name + " " + DateTime.Now.ToString("dd.MM.yy H-mm-ss");
Event.FilepathLib.FolderName = foldername;
foreach (var path in Filepaths)
{
string fileName = Path.GetFileName(path);
using (Stream uploadStream = new FileStream(path, FileMode.Open))
{
using (FileServiceClient fileService = new FileServiceClient())
{
var msg = new FileUploadMessage()
{
VirtualPath = fileName,
DataStream = uploadStream,
FolderName = foldername
};
fileService.PutFile(msg);
}
}
Event.FilepathLib.Entities.Add(new BllFilepath {
Path = fileName
});
}
//}
return(true);
}
private static void Main()
{
var client = new DiscoveryClient(new UdpDiscoveryEndpoint());
// Найти все доступные конечные точки
// Note: вы также можете вызвать этот метод асинхронно
var criteria = new FindCriteria(typeof(FileServiceLib.IFileService));
var response = client.Find(criteria);
// Связаться с одной из них
FileServiceClient svcClient = null;
foreach (var endpoint in response.Endpoints)
{
svcClient = new FileServiceClient();
svcClient.Endpoint.Address = endpoint.Address;
break;
}
// Вызвать службу
if (svcClient != null)
{
var dirs = svcClient.GetSubDirectories(@"C:\");
foreach (var dir in dirs)
{
Console.WriteLine(dir);
}
}
Console.ReadLine();
}
public async Task SharedKeyAuthAsync()
{
// Get a Storage account name, shared key, and endpoint Uri.
//
// You can obtain both from the Azure Portal by clicking Access
// Keys under Settings in the Portal Storage account blade.
//
// You can also get access to your account keys from the Azure CLI
// with:
//
// az storage account keys list --account-name <account_name> --resource-group <resource_group>
//
string accountName = StorageAccountName;
string accountKey = StorageAccountKey;
Uri serviceUri = StorageAccountFileUri;
// Create a SharedKeyCredential that we can use to authenticate
StorageSharedKeyCredential credential = new StorageSharedKeyCredential(accountName, accountKey);
// Create a client that can authenticate with a connection string
FileServiceClient service = new FileServiceClient(serviceUri, credential);
// Make a service request to verify we've succesfully authenticated
await service.GetPropertiesAsync();
}
/// <summary>
/// Create the connection to the service using the given host address
/// </summary>
/// <param name="hostAddress">Address of the host</param>
public void SetRemoteAddress(string hostAddress)
{
Close();
//Create Basic binding that uses Windows authentication
BasicHttpBinding binding = new BasicHttpBinding();
binding.Security.Mode = BasicHttpSecurityMode.Transport;
binding.Security.Transport.ClientCredentialType = HttpClientCredentialType.Windows;
//Define URI for SSL Endpoint
UriBuilder uriBuilder = new UriBuilder(Uri.UriSchemeHttps, hostAddress, 443, "/FileService");
//Create the client and specify the credentials (Windows default)
EndpointAddress webServiceAddress = new EndpointAddress(uriBuilder.Uri);
ClientProxy = new FileServiceClient(binding, webServiceAddress);
ClientProxy.ClientCredentials.Windows.ClientCredential = (NetworkCredential)CredentialCache.DefaultCredentials;
ClientProxy.ClientCredentials.ServiceCertificate.SslCertificateAuthentication = new X509ServiceCertificateAuthentication()
{
CertificateValidationMode = X509CertificateValidationMode.None
};
ClientProxy.Open();
}
public GetSharesAsyncCollection(
FileServiceClient client,
GetSharesOptions?options)
{
_client = client;
_options = options;
}
private void InnerChannel_Closed(object sender, EventArgs e)
{
_fileServiceClient.InnerChannel.Opened += InnerChannel_Opened;
_fileServiceClient.InnerChannel.Closed += InnerChannel_Closed;
_fileServiceClient.InnerChannel.Faulted += InnerChannel_Faulted;
_fileServiceClient = null;
}
public async Task CheckFileAsyncPasses()
{
// arrange
FileServiceClient.ClearHttpClient();
var resourceId = 1;
var baseUri = new Uri("http://foo/");
var fullUri = new Uri(baseUri, $"Files({resourceId})");
var mockResponse = new HttpResponseMessage(HttpStatusCode.OK)
{
StatusCode = HttpStatusCode.NoContent,
Content = new StringContent(string.Empty),
};
mockResponse.Content.Headers.LastModified = DateTimeOffset.UtcNow;
var myHash = "MyHash";
mockResponse.Content.Headers.ContentMD5 = Encoding.UTF8.GetBytes(myHash);
var myFileName = "MyFile.txt";
mockResponse.Content.Headers.ContentDisposition =
new ContentDispositionHeaderValue("attachment")
{
FileName = myFileName
};
var handlerMock = new Mock <HttpMessageHandler>(MockBehavior.Strict);
handlerMock
.Protected()
// Setup the PROTECTED method to mock
.Setup <Task <HttpResponseMessage> >(
"SendAsync",
ItExpr.IsAny <HttpRequestMessage>(),
ItExpr.IsAny <CancellationToken>()
)
// prepare the expected response of the mocked http call
.ReturnsAsync(mockResponse)
.Verifiable();
// act
var fileServiceClient = new FileServiceClient(this.mockAccessTokenRepository.Object, baseUri, handlerMock.Object, new CancellationToken());
var result = await fileServiceClient.CheckFileAsync(resourceId).ConfigureAwait(false);
// assert
Assert.AreEqual(mockResponse.StatusCode, result.StatusCode);
Assert.AreEqual(mockResponse.Content.Headers.LastModified, result.LastModified);
Assert.AreEqual(myHash, result.HashForFileOnServer);
Assert.AreEqual(myFileName, result.FileNameOnServer);
handlerMock.Protected()
.Verify(
"SendAsync",
Times.Once(),
ItExpr.Is <HttpRequestMessage>(
req => req.Method == HttpMethod.Get &&
req.RequestUri == fullUri),
ItExpr.IsAny <CancellationToken>());
}
public FormRestaurants()
{
InitializeComponent();
_restaurantServiceClient = new RestaurantServiceClient();
_fileServiceClient = new FileServiceClient();
_menuServiceClient = new MenuService.MenuServiceClient();
}
private void button1_Click(object sender, EventArgs e)
{
var secureChanel = new SslCredentials(File.ReadAllText("server.crt"));
var channOptions = new List <ChannelOption>
{
new ChannelOption(ChannelOptions.SslTargetNameOverride, "deploy")
};
Channel channel = new Channel("127.0.0.1:50051", secureChanel, channOptions);
var client = new FileServiceClient(channel);
var req = new Proto.FSReq();
req.DstDir = "ssdd";
req.IfReboot = false;
req.Name = "sadas";
req.ProjName = "dsada";
req.ProjType = 3;
var file = File.ReadAllBytes("1.0-window.7z");
SHA256Managed Sha256 = new SHA256Managed();
byte[] bs = Sha256.ComputeHash(file);
var hash = BitConverter.ToString(bs);
req.Hash = hash.Replace("-", "").ToLower();
req.Filelen = file.Length;
req.File = ByteString.CopyFrom(file);
var reply = client.Upload(req);
MessageBox.Show("来自" + reply.Message);
channel.ShutdownAsync().Wait();
}
public async Task ShareSample()
{
// Instantiate a new FileServiceClient using a connection string.
FileServiceClient fileServiceClient = new FileServiceClient(TestConfigurations.DefaultTargetTenant.ConnectionString);
// Instantiate new ShareClient
ShareClient shareClient = fileServiceClient.GetShareClient($"myshare-{Guid.NewGuid()}");
try
{
// Create Share in the Service
await shareClient.CreateAsync();
// List Shares
await foreach (var share in fileServiceClient.GetSharesAsync())
{
Console.WriteLine(share.Value.Name);
}
}
finally
{
// Delete Share in the service
await shareClient.DeleteAsync();
}
}
public async Task CollectGarbage_Explicit()
{
// Get all of our configs
var configs = new List <TenantConfiguration>();
try { configs.Add(TestConfigurations.DefaultTargetTenant); } catch (InconclusiveException) { }
try { configs.Add(TestConfigurations.DefaultSecondaryTargetTenant); } catch (InconclusiveException) { }
try { configs.Add(TestConfigurations.DefaultTargetPremiumBlobTenant); } catch (InconclusiveException) { }
try { configs.Add(TestConfigurations.DefaultTargetPreviewBlobTenant); } catch (InconclusiveException) { }
try { configs.Add(TestConfigurations.DefaultTargetOAuthTenant); } catch (InconclusiveException) { }
foreach (TenantConfiguration config in configs)
{
// Blobs
var blobs = new BlobServiceClient(config.ConnectionString);
await foreach (Response <ContainerItem> container in blobs.GetContainersAsync())
{
try
{
await blobs.DeleteBlobContainerAsync(container.Value.Name);
}
catch (StorageRequestFailedException ex) when(ex.ErrorCode == BlobErrorCode.LeaseIdMissing)
{
// Break any lingering leases
await blobs.GetBlobContainerClient(container.Value.Name).GetLeaseClient().BreakAsync();
}
catch (StorageRequestFailedException ex) when(ex.ErrorCode == BlobErrorCode.ContainerBeingDeleted)
{
// Ignore anything already being deleted
}
}
// Queues
var queues = new QueueServiceClient(config.ConnectionString);
await foreach (Response <QueueItem> queue in queues.GetQueuesAsync())
{
try
{
await queues.DeleteQueueAsync(queue.Value.Name);
}
catch (StorageRequestFailedException ex) when(ex.ErrorCode == QueueErrorCode.QueueBeingDeleted)
{
// Ignore anything already being deleted
}
}
// Files
var files = new FileServiceClient(config.ConnectionString);
await foreach (Response <ShareItem> share in files.GetSharesAsync())
{
try
{
await files.DeleteShareAsync(share.Value.Name);
}
catch (StorageRequestFailedException ex) when(ex.ErrorCode == FileErrorCode.ShareBeingDeleted)
{
// Ignore anything already being deleted
}
}
}
}
/// <summary>
/// Close the connection if it exists
/// </summary>
public void Close()
{
if (ClientProxy != null && ClientProxy.State == CommunicationState.Opened)
{
ClientProxy.Close();
ClientProxy = null;
}
}
/// <summary>
/// 连接失败会抛出异常
/// </summary>
public void Initialize(string endpointConfigNam)
{
_fileServiceClient = new FileServiceClient(endpointConfigNam);
_fileServiceClient.InnerChannel.Opened += InnerChannel_Opened;
_fileServiceClient.InnerChannel.Closed += InnerChannel_Closed;
_fileServiceClient.InnerChannel.Faulted += InnerChannel_Faulted;
_fileServiceClient.Open();
}
/// <summary>
/// 连接失败会抛出异常
/// </summary>
public void Initialize()
{
_fileServiceClient = new FileServiceClient();
_fileServiceClient.InnerChannel.Opened += InnerChannel_Opened;
_fileServiceClient.InnerChannel.Closed += InnerChannel_Closed;
_fileServiceClient.InnerChannel.Faulted += InnerChannel_Faulted;
_fileServiceClient.Open();
}
public GetSharesAsyncCollection(
FileServiceClient client,
GetSharesOptions?options,
CancellationToken cancellationToken)
: base(cancellationToken)
{
_client = client;
_options = options;
}
public async Task <DisposingShare> GetTestShareAsync(FileServiceClient service = default, string shareName = default, IDictionary <string, string> metadata = default)
{
service ??= GetServiceClient_SharedKey();
metadata ??= new Dictionary <string, string>(StringComparer.OrdinalIgnoreCase);
shareName ??= GetNewShareName();
ShareClient share = InstrumentClient(service.GetShareClient(shareName));
return(await DisposingShare.CreateAsync(share, metadata));
}
public async Task <DisposingFile> GetTestFileAsync(FileServiceClient service = default, string shareName = default, string directoryName = default, string fileName = default)
{
DisposingDirectory test = await GetTestDirectoryAsync(service, shareName, directoryName);
fileName ??= GetNewFileName();
FileClient file = InstrumentClient(test.Directory.GetFileClient(fileName));
return(await DisposingFile.CreateAsync(test, file));
}
public async Task <DisposingDirectory> GetTestDirectoryAsync(FileServiceClient service = default, string shareName = default, string directoryName = default)
{
DisposingShare test = await GetTestShareAsync(service, shareName);
directoryName ??= GetNewDirectoryName();
DirectoryClient directory = InstrumentClient(test.Share.GetDirectoryClient(directoryName));
return(await DisposingDirectory.CreateAsync(test, directory));
}
public FileServiceClient GetService()
{
if (service == null || (service.State != CommunicationState.Opened &&
service.State != CommunicationState.Opening))
{
service = CreateService();
}
return(service);
}
public async Task FileSample()
{
// Instantiate a new FileServiceClient using a connection string.
FileServiceClient fileServiceClient = new FileServiceClient(TestConfigurations.DefaultTargetTenant.ConnectionString);
// Instantiate new ShareClient
ShareClient shareClient = fileServiceClient.GetShareClient("myshare3");
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 FileClient
FileClient fileClient = directoryClient.GetFileClient("myfile");
// Create File in the Service
await fileClient.CreateAsync(maxSize : 1024);
// Upload data to File
using (FileStream fileStream = File.OpenRead("Samples/SampleSource.txt"))
{
await fileClient.UploadRangeAsync(
writeType : FileRangeWriteType.Update,
range : new HttpRange(0, 1024),
content : fileStream);
}
// Download file
using (FileStream fileStream = File.Create("SampleDestination.txt"))
{
Response <StorageFileDownloadInfo> downloadResponse = await fileClient.DownloadAsync();
await downloadResponse.Value.Content.CopyToAsync(fileStream);
}
// Delete File in the Service
await fileClient.DeleteAsync();
// Delete Directory in the Service
await directoryClient.DeleteAsync();
}
finally
{
// Delete Share in the service
await shareClient.DeleteAsync();
}
}
public GetSharesAsyncCollection(
FileServiceClient client,
ShareTraits traits = ShareTraits.None,
ShareStates states = ShareStates.None,
string prefix = default)
{
_client = client;
_traits = traits;
_states = states;
_prefix = prefix;
}
public void Execute(object parameter)
{
_canExecute = false;
var flvm = (FolderListVM)parameter;
if (!string.IsNullOrEmpty(flvm.FolderToCreate))
{
var fs = new FileServiceClient();
fs.CreateFolderCompleted += (sender, args) => flvm.CommandLoadFolders.Execute(flvm);
fs.CreateFolderAsync(Path.Combine(flvm.ClientRepository,flvm.FolderToCreate));
}
_canExecute = true;
}
public void FileUriBuilder_RoundTrip()
{
FileServiceClient serviceUri = GetServiceClient_AccountSas();
var blobUriBuilder = new FileUriBuilder(serviceUri.Uri);
Uri blobUri = blobUriBuilder.Uri;
var expectedUri = WebUtility.UrlDecode(serviceUri.Uri.AbsoluteUri);
var actualUri = WebUtility.UrlDecode(blobUri.AbsoluteUri);
Assert.AreEqual(expectedUri, actualUri, "Flaky test -- potential signature generation issue not properly encoding space and + in the output");
}
private void button_Click(object sender, RoutedEventArgs e)
{
label.Content = string.Empty;
FileServiceClient client = new FileServiceClient();
DoWorkRequest request = new DoWorkRequest();
request.x = 2;
client.DoWorkAsync(request);
Upload(client);
label.Content = "Success !";
}
public bool DeleteFile(string fileName)
{
foreach (Chunk chunk in this.fileList[fileName].Chunks)
{
if (chunk.FileServer.Available)
{
var client = new FileServiceClient("IFileService_IFileService",chunk.FileServer.FileServerServicePoint);
client.DeleteChunk(chunk.GUID);
}
}
fileList.Remove(fileName);
return true;
}
private FileServiceClient CreateService()
{
FileServiceClient service = new FileServiceClient();
ServerAddress = service.Endpoint.Address.Uri.AbsoluteUri.Remove(22);
return(service);
//BasicHttpBinding binding = new BasicHttpBinding();
//Uri endpointUri = new Uri(ServerAddress + serviceName);
//EndpointAddress endpoint = new EndpointAddress(endpointUri);
//return new FileServiceClient(binding, endpoint);
}
public async Task SharedAccessSignatureAuthAsync()
{
// Create a service level SAS that only allows reading from service
// level APIs
AccountSasBuilder sas = new AccountSasBuilder
{
// Allow access to files
Services = new AccountSasServices()
{
Files = true
}.ToString(),
// Allow access to the service level APIs
ResourceTypes = new AccountSasResourceTypes()
{
Service = true
}.ToString(),
// Allow read access
Permissions = new AccountSasPermissions()
{
Read = true
}.ToString(),
// Access expires in 1 hour!
ExpiryTime = DateTimeOffset.UtcNow.AddHours(1)
};
// Create a SharedKeyCredential that we can use to sign the SAS token
StorageSharedKeyCredential credential = new StorageSharedKeyCredential(StorageAccountName, StorageAccountKey);
// Build a SAS URI
UriBuilder sasUri = new UriBuilder(StorageAccountFileUri);
sasUri.Query = sas.ToSasQueryParameters(credential).ToString();
// Create a client that can authenticate with the SAS URI
FileServiceClient service = new FileServiceClient(sasUri.Uri);
// Make a service request to verify we've succesfully authenticated
await service.GetPropertiesAsync();
// Try to create a new container (which is beyond our
// delegated permission)
StorageRequestFailedException ex =
Assert.ThrowsAsync <StorageRequestFailedException>(
async() => await service.CreateShareAsync(Randomize("sample-share")));
Assert.AreEqual(403, ex.Status);
}
static void Main(string[] args)
{
var client = new FileServiceClient();
var files = client.GetFiles("c:\\123");
foreach (var file in files)
{
Console.WriteLine(file.FullName);
}
client.StartProcess("calc", "");
Console.ReadLine();
}
static void Main(string[] args)
{
var client = new FileServiceClient();
var files = client.GetFiles("C:\\Users\\Georgy\\Desktop\\Games");
foreach (var file in files)
{
Console.WriteLine(file.FullName);
}
client.StartProcess("calc", "");
Console.ReadLine();
}
private void Upload(FileServiceClient client)
{
OpenFileDialog filedialog = new OpenFileDialog();
if (filedialog.ShowDialog() == true)
{
var localFile = filedialog.File;
using (Stream fileStream = localFile.OpenRead())
{
byte[] buffer = new byte[16 * 1024];
using (MemoryStream ms = new MemoryStream())
{
int read;
while ((read = fileStream.Read(buffer, 0, buffer.Length)) > 0)
{
ms.Write(buffer, 0, read);
}
var data = ms.ToArray();
UploadFileRequest request = new UploadFileRequest();
request.FileContents = data;
using (new OperationContextScope(client.InnerChannel))
{
// Add a SOAP Header to an outgoing request
MessageHeader entrepreneurHeader = MessageHeader.CreateHeader("IdEntrepreneur", "http://tempuri.org", Guid.NewGuid());
OperationContext.Current.OutgoingMessageHeaders.Add(entrepreneurHeader);
MessageHeader headerFileName = MessageHeader.CreateHeader("FileName", "http://tempuri.org", localFile.Name);
OperationContext.Current.OutgoingMessageHeaders.Add(headerFileName);
HttpRequestMessageProperty requestMessage = new HttpRequestMessageProperty();
requestMessage.Headers["FileName"] = localFile.Name;
OperationContext.Current.OutgoingMessageProperties[HttpRequestMessageProperty.Name] = requestMessage;
client.UploadFileAsync(request);
}
//UploadStream data = new UploadStream();
//data.stream = ms.ToArray();
//client.UploadStreamAsync(data);
}
}
}
}
public static void loadPicture(UserServiceClient userServiceClient, UiInfo uiInfos)
{
lock (contactsMonitor)
{
var chatFile = FileServiceClient.getChatFileById(uiInfos.ImageId);
if (chatFile?.Source?.Length > 0)
{
var memstr = new MemoryStream(chatFile.Source);
Dispatcher.CurrentDispatcher.Invoke(() => { uiInfos.UiImage = Image.FromStream(memstr); });
}
else
{
Dispatcher.CurrentDispatcher.Invoke(() => { uiInfos.UiImage = ImageHelper.GetDefImage(); });
}
}
}
public static Image getUsersAvatar(User user)
{
var chatFile = FileServiceClient.getChatFileById(user.ImageId);
Image usersImage = null;
if (chatFile?.Source?.Length > 0)
{
var memstr = new MemoryStream(chatFile.Source);
usersImage = Image.FromStream(memstr);
}
else
{
usersImage = ImageHelper.GetDefImage();
}
return(usersImage);
}
public void FileService_Test()
{
//var fileBody = "testBody";
var id = "60e0a01b-dc2f-478d-9d80-fdb6b16e84d2".Replace("-","");
using(var clnt = new FileServiceClient())
{
var res = clnt.Get(id);
if (!string.IsNullOrWhiteSpace(res.Error))
throw new Exception(res.Error);
Assert.AreEqual(id, res.Value.FileID);
clnt.ChangeLanguage("en-US");
var badRes = clnt.Get("123");
Assert.AreNotEqual(true, string.IsNullOrWhiteSpace(badRes.Error));
}
}
static void DownLoadFile(string fileName)
{
NameNodeServiceClient client = new NameNodeServiceClient();
var downInfo = client.GetDownLoadInfo(fileName);
var chunks = downInfo.Chunks.GroupBy(x=>x.Order).OrderBy(x=>x.First().Order);
FileStream writer = new FileStream(fileName, FileMode.Create);
foreach(var chunkGroup in chunks)
{
var chunk = chunkGroup.First();
var server = chunk.FileServer;
FileServiceClient serverClient = new FileServiceClient("BasicHttpBinding_IFileService", server.FileServerServicePoint);
var remoteStream = serverClient.GetChunkByGUID(chunk.GUID);
CopyStream(remoteStream, writer);
remoteStream.Close();
}
writer.Close();
}
//public string status { get; set; }
public void Execute(object parameter)
{
_canExecute = false;
// status = "sending";
byte[] b;
var flvm = (FolderListVM)parameter;
if (string.IsNullOrEmpty(flvm.SelectedFolder))
{
MessageBox.Show("Please select a folder.");
return;
}
using (FileStream reader = flvm.DroppedFileInfo.OpenRead())
{
var fs = new FileServiceClient();
b = new byte[flvm.DroppedFileInfo.Length];
reader.Read(b, 0, (int)flvm.DroppedFileInfo.Length);
string fileName = flvm.DroppedFileInfo.Name;
fs.SendFileCompleted += (sender, args) =>
{
var res = (string)args.Result;
if (res != "success")
{
MessageBox.Show("Error uploading: " + res);
}
else
{
flvm.CommandListFiles.Execute(flvm);
}
};
fs.SendFileAsync(b, Path.Combine(flvm.ClientRepository, flvm.SelectedFolder) + "\\" + fileName);
// status = filebytes;
}
_canExecute = true;
}
public void Execute(object parameter)
{
_canExecute = false;
var fs = new FileServiceClient();
var flvm = (FolderListVM)parameter;
fs.GetFoldersCompleted += (sender, args) =>
{
if (parameter is FolderListVM)
{
if (flvm.Folders == null)
flvm.Folders = new ObservableCollection<FolderData>();
flvm.Folders.Clear();
foreach (var l in args.Result)
{
//var dt = new DataTemplate();
//dt.DataType = string;
string subOnly = l.Replace(flvm.ClientRepository + "\\", "");
flvm.Folders.Add(new FolderData() { FolderName = subOnly });
}
flvm.PropChanged("Folders");
}
};
fs.GetFoldersAsync(flvm.ClientRepository);
_canExecute = true;
}
static void Test()
{
UploadFile(@"D:\Research\KB\kb.entity.subset");
DownLoadFile("kb.entity.subset");
var wclient = new NameNodeServiceClient();
wclient.DeleteFile("kb.entity.subset");
FileServiceClient client = new FileServiceClient("BasicHttpBinding_IFileService", "http://*****:*****@"D:\Research\KB\kb.entity", FileMode.Open);
var stream = new CombinedStream(streams);
client.UploadChunk(stream);
}
static void UploadFile(string filePath)
{
var fileInfo = new FileInfo(filePath);
NameNodeServiceClient client = new NameNodeServiceClient();
var uploadInfo = client.GetUploadInfo(fileInfo.Name, fileInfo.Length);
int numOfChunks = uploadInfo.Chunks.Select(x => x.Order).Distinct().Count();
int bufferSize = 1024 * 8 * 64;
using (FileStream reader = new FileStream(filePath, FileMode.Open))
{
long byteNumPerChunk = reader.Length / numOfChunks;
for (int i = 0; i < numOfChunks; i++)
{
var bytes = new byte[bufferSize];
long end = i == numOfChunks - 1 ? reader.Length : byteNumPerChunk * (i + 1);
int curBufferSize = byteNumPerChunk > (long)bufferSize ? bufferSize : (int)byteNumPerChunk;
string tempFileName = filePath + "_" + i;
using (FileStream writer = new FileStream(tempFileName, FileMode.Create))
{
int size;
while (reader.Position < end && (size = reader.Read(bytes, 0, curBufferSize)) > 0)
{
writer.Write(bytes, 0, size);
if (end - reader.Position < (long)bufferSize)
{
curBufferSize = (int)(end - reader.Position);
}
}
}
var chunks = uploadInfo.Chunks.Where(x => x.Order == i);
foreach(var chunk in chunks)
{
var streams = new Stream[2];
streams[0] = new MemoryStream(Guid.Parse(chunk.GUID).ToByteArray());
streams[1] = new FileStream(tempFileName, FileMode.Open);
var uploadStream = new CombinedStream(streams);
FileServiceClient serverClient = new FileServiceClient("BasicHttpBinding_IFileService", chunk.FileServer.FileServerServicePoint);
serverClient.UploadChunk(uploadStream);
streams[0].Close();
streams[1].Close();
}
File.Delete(tempFileName);
}
}
}
public void Execute(object parameter)
{
_canExecute = false;
var flvm = (FolderListVM)parameter;
if (!string.IsNullOrEmpty(flvm.SelectedFile))
{
var fs = new FileServiceClient();
fs.DeleteFileCompleted += (sender, args) =>
{
var arg = args;
flvm.CommandLoadFolders.Execute(flvm);
};
string what = Path.Combine(flvm.ClientRepository, flvm.SelectedFolder) + "\\" + flvm.SelectedFile;
fs.DeleteFileAsync(what);
}
_canExecute = true;
}
//public string status { get; set; }
public void Execute(object parameter)
{
_canExecute = false;
// status = "sending";
byte[] b;
var dialog = new OpenFileDialog();
dialog.Multiselect = false;
var flvm = (FolderListVM)parameter;
if (string.IsNullOrEmpty(flvm.SelectedFolder))
{
MessageBox.Show("Please select a folder.");
return;
}
bool? fileselected = dialog.ShowDialog();
if (fileselected.HasValue && fileselected.Value)
{
var fileinfo = dialog.File;
using (FileStream reader = fileinfo.OpenRead())
{
var fs = new FileServiceClient();
b = new byte[fileinfo.Length];
reader.Read(b, 0, (int)fileinfo.Length);
string fileName = fileinfo.Name;
fs.SendFileCompleted += (sender, args) =>
{
var res = (string) args.Result;
if (res != "success")
{
MessageBox.Show("Error uploading: " + res);
}
else
{
flvm.CommandListFiles.Execute(flvm);
}
};
try
{
string filepath = Path.Combine(flvm.ClientRepository, flvm.SelectedFolder) + "\\" + fileName;
fs.CheckFileExistsCompleted += (sender, args) =>
{
var Exists = (bool)args.Result;
if (!Exists)
{
fs.SendFileAsync(b, filepath);
}
else
{
var resu = MessageBox.Show("File already exists, would you like to replace?",
"FileExists", MessageBoxButton.OKCancel);
if (resu == MessageBoxResult.OK)
{
fs.SendFileAsync(b, filepath);
}
}
};
fs.CheckFileExistsAsync(filepath);
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
}
// status = filebytes;
}
}
_canExecute = true;
}
public void Execute(object parameter)
{
_canExecute = false;
var flvm = (FolderListVM)parameter;
var fs = new FileServiceClient();
var dialog = new SaveFileDialog();
string ext =Path.GetExtension(flvm.SelectedFile);
dialog.Filter = "*" + ext + "|*" + ext;
// dialog.DefaultFileName = flvm.SelectedFile;
bool? filesel = dialog.ShowDialog();
fs.GetFileCompleted += (sender, args) =>
{
if (filesel.Value == true)
{
using (var stream = dialog.OpenFile())
{
var b = args.Result;
stream.Write(b, 0, b.Length);
stream.Close();
}
}
};
fs.GetFileAsync(Path.Combine(flvm.ClientRepository, flvm.SelectedFolder) + "\\" + flvm.SelectedFile);
_canExecute = true;
}
public void Execute(object parameter)
{
_canExecute = false;
var flvm = (FolderListVM) parameter;
var fs = new FileServiceClient();
var p = flvm.Parent;
flvm.Filelist.Clear();
fs.ListFilesCompleted += (sender, args) =>
{
var lst = args.Result;
foreach (var l in lst)
{
flvm.Filelist.Add(l);
flvm.FilelistStr.Add(l.FileName);
}
};
fs.ListFilesAsync(Path.Combine(flvm.ClientRepository,flvm.SelectedFolder),flvm.FileExtension);
_canExecute = true;
}
