private static void Download(string fileName)
{
var file = _folderPathDownload + fileName;
using (var fileStream = File.Create(file))
{
_storageClient.DownloadObject(_bucketName, fileName, fileStream);
}
}
public override string ReadAllText(string path)
{
using (var stream = new MemoryStream())
{
_storageClient.DownloadObject(_bucketName, path, stream);
using (StreamReader reader = new StreamReader(stream))
{
return(reader.ReadToEnd());
}
}
}
public void download(string bucket_name, string key_name, Stream stream)
{
try
{
client.DownloadObject(bucket_name, key_name, stream);
stream.Flush();
}
catch (Exception ex)
{
throw new Exception("Error while trying to download from GCP \""
+ bucket_name + "\\" + key_name + "\". GCP error message: "
+ ex.Message);
}
}
// Import CSV file from Google Storage bucket into existing Google BigQuery data table
private void ImportFileFromStorageToBigQuery(BigqueryClient client, string projectName,
string bucketName, string fileName, string dataSetName, string tableName)
{
StorageClient gcsClient = StorageClient.Create(_GoogleAPICredential);
using (var stream = new MemoryStream())
{
gcsClient.DownloadObject(bucketName, fileName, stream);
// This uploads data to an existing table. If the upload will create a new table
// or if the schema in the CSV isn't identical to the schema in the table,
// create a schema to pass into the call instead of passing in a null value.
BigqueryJob job = null;
try
{
job = client.UploadCsv(dataSetName, tableName, null, stream);
}
catch (Exception e)
{
string m = e.Message;
}
// Use the job to find out when the data has finished being inserted into the table,
// report errors etc.
// Wait for the job to complete.
try
{
job.Poll();
} catch (Exception e) {
string m = e.Message;
}
}
}
public StorageData Get(StorageFileId storageFileId)
{
var pdfBytes = new MemoryStream();
_storageClient.DownloadObject(_settings.GoogleBucketName, GetObjectName(storageFileId), pdfBytes, null, null);
return(new StorageData(storageFileId, pdfBytes.ToArray()));
}
/// <summary>
/// Download a file object from GCS
/// </summary>
private void DownloadObject(StorageClient client, Google.Apis.Storage.v1.Data.Object gcsObject,
FileObject fileObject, ObjectVersion version)
{
try
{
using (MemoryStream memStm = new MemoryStream())
{
Console.ForegroundColor = ConsoleColor.Gray;
Helpers.WriteProgress(0);
_fileSize = (long)gcsObject.Size.GetValueOrDefault();
client.DownloadObject(gcsObject, memStm, new DownloadObjectOptions()
{
Generation = version.Generation
}, this);
memStm.Position = 0;
fileObject.DataContent = memStm.ToArray();
}
}
catch (Exception ex)
{
throw new SmkException(string.Format(ErrorResources.GcsBucketSource_DownloadingError, gcsObject.Name), ex);
}
}
public TagValueResponse[] GetPLCData([FromBody] RquestObj req)
{
TagValueResponse[] resp = null;
try
{
//DateTime chrtdate_from, chrtdate_to;
//GraphTypeDC[] objOutPutDataDCarray = null;
//chrtdate_from = Convert.ToDateTime(FromDate);
//chrtdate_to = Convert.ToDateTime(ToDate);
//objOutPutDataDCarray = WcfService.objHMI2.STUB_GetAIEQuipFlag(chrtdate_from, chrtdate_to, EqpNO, Scenarios);
//return objOutPutDataDCarray;
string projectId = "projamdstrial";
DateTime chrtdate_from, chrtdate_to;
chrtdate_from = Convert.ToDateTime(req.FromDate);
chrtdate_to = Convert.ToDateTime(req.ToDate);
// Instantiates a client.
using (StorageClient storageClient = StorageClient.Create())
{
// The name for the new bucket.
string bucketName = "TestAMDSData/BFProcess_FBF_DATA_HEARTH_2020_1_28_20200128073415.csv";
try
{
// Creates the new bucket.
var bucket = storageClient.GetBucket("amds_bucket");
using (MemoryStream mem = new MemoryStream())
{
storageClient.DownloadObject("amds_bucket", bucketName, mem);
//StreamReader reader = new StreamReader(mem);
//string content = reader.ReadToEnd();
string content = Encoding.ASCII.GetString(mem.ToArray());
string[] sep = { "\n" };
List <string> lines = content.Split(sep, StringSplitOptions.RemoveEmptyEntries).ToList();
lines.RemoveAt(0);
List <TagValueResponse> dataList = new List <TagValueResponse>();
lines.ForEach(x => dataList.Add(new TagValueResponse()
{
READTIME = Convert.ToDateTime(x.Split(',')[0]),
TAGID = Convert.ToInt32(x.Split(',')[1]),
VALUE = Convert.ToDecimal(x.Split(',')[2])
}));
resp = dataList.Where(x => x.READTIME >= chrtdate_from && x.READTIME <= chrtdate_to && x.TAGID == req.TAGID).ToArray();
}
Console.WriteLine($"Bucket {bucketName} created.");
}
catch (Google.GoogleApiException e)
when(e.Error.Code == 409)
{
// The bucket already exists. That's fine.
Console.WriteLine(e.Error.Message);
}
}
return(resp);
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
}
// [END delete_table]
// [START import_file_from_gcs]
public void ImportDataFromCloudStorage(string projectId, string datasetId,
string tableId, BigqueryClient client, string fileName, string folder = null)
{
StorageClient gcsClient = StorageClient.Create();
using (var stream = new MemoryStream())
{
// Set Cloud Storage Bucket name. This uses a bucket named the same as the project.
string bucket = projectId;
// If folder is passed in, add it to Cloud Storage File Path using "/" character
string filePath = string.IsNullOrEmpty(folder) ? fileName : folder + "/" + fileName;
// Download Google Cloud Storage object into stream
gcsClient.DownloadObject(projectId, filePath, stream);
// This example uploads data to an existing table. If the upload will create a new table
// or if the schema in the JSON isn't identical to the schema in the table,
// create a schema to pass into the call instead of passing in a null value.
BigqueryJob job = client.UploadJson(datasetId, tableId, null, stream);
// Use the job to find out when the data has finished being inserted into the table,
// report errors etc.
// Wait for the job to complete.
job.PollUntilCompleted();
}
}
public void StartLoadingImage()
{
using (var stream = new MemoryStream())
{
try
{
this.ImageObj.MediaLink = ImageObj.MediaLink + "=s32-c";
this.ImageObj.SelfLink = ImageObj.SelfLink + "=s32-c";
//storage.Service.
storage.DownloadObject(ImageObj, stream);
stream?.Seek(0, SeekOrigin.Begin);
var bitmap = new BitmapImage();
bitmap.BeginInit();
//bitmap.DecodePixelHeight = 230;
bitmap.DecodePixelWidth = 230;
bitmap.StreamSource = stream;
bitmap.CacheOption = BitmapCacheOption.OnLoad; //BitmapCacheOption.OnLoad;
//bitmap.CreateOptions = BitmapCreateOptions.DelayCreation;
bitmap.EndInit();
bitmap.Freeze();
//No need to wait for this to finish
//ImageInfo(bitmap, obj);
Data = bitmap;
}
catch (Exception ex)
{
Data = new BitmapImage();
}
}
}
public BitmapImage GetBitmap(Google.Apis.Storage.v1.Data.Object obj)
{
using (var stream = new MemoryStream())
{
try
{
//obj.MediaLink = obj.MediaLink + "=s32-c";
//obj.SelfLink = obj.SelfLink + "=s32-c";
//storage.Service.
storage.DownloadObject(obj, stream);
stream?.Seek(0, SeekOrigin.Begin);
var bitmap = new BitmapImage();
bitmap.BeginInit();
bitmap.DecodePixelHeight = 230;
bitmap.DecodePixelWidth = 230;
bitmap.StreamSource = stream;
bitmap.CacheOption = BitmapCacheOption.OnLoad;
bitmap.EndInit();
bitmap.Freeze();
//No need to wait for this to finish
//ImageInfo(bitmap, obj);
return(bitmap);
}catch (Exception ex)
{
return(new BitmapImage());
}
}
}
public void ExportCsv()
{
// TODO: Make this simpler in the wrapper
var projectId = _fixture.ProjectId;
var datasetId = _fixture.GameDatasetId;
var historyTableId = _fixture.HistoryTableId;
string bucket = "bigquerysnippets-" + Guid.NewGuid().ToString().ToLowerInvariant();
string objectName = "table.csv";
if (!WaitForStreamingBufferToEmpty(historyTableId))
{
Console.WriteLine("Streaming buffer not empty after 30 seconds; not performing export");
return;
}
// Sample: ExportCsv
BigqueryClient client = BigqueryClient.Create(projectId);
// Create a storage bucket; in normal use it's likely that one would exist already.
StorageClient storageClient = StorageClient.Create();
storageClient.CreateBucket(projectId, bucket);
string destinationUri = $"gs://{bucket}/{objectName}";
Job job = client.Service.Jobs.Insert(new Job
{
Configuration = new JobConfiguration
{
Extract = new JobConfigurationExtract
{
DestinationFormat = "CSV",
DestinationUris = new[] { destinationUri },
SourceTable = client.GetTableReference(datasetId, historyTableId)
}
}
}, projectId).Execute();
// Wait until the export has finished.
var result = client.PollJob(job.JobReference);
// If there are any errors, display them *then* fail.
if (result.Status.ErrorResult != null)
{
foreach (var error in result.Status.Errors)
{
Console.WriteLine(error.Message);
}
}
Assert.Null(result.Status.ErrorResult);
MemoryStream stream = new MemoryStream();
storageClient.DownloadObject(bucket, objectName, stream);
Console.WriteLine(Encoding.UTF8.GetString(stream.ToArray()));
// End sample
storageClient.DeleteObject(bucket, objectName);
storageClient.DeleteBucket(bucket);
}
public Stream GetStream()
{
var outputStream = new MemoryStream();
Client.DownloadObject(Object, outputStream);
outputStream.Position = 0;
return(outputStream);
}
public async Task <Stream> GetFile(string path)
{
var mem = new MemoryStream();
storage.DownloadObject(BUCKET_NAME, path, mem);
mem.Position = 0;
return(mem);
}
private void TryDownloadObject(string bucket, GcsObject obj, string destinationFile)
{
using (var outputFile = _fileSystem.File.OpenWrite(destinationFile))
{
_storageClient.DownloadObject(bucket, obj.Name, outputFile);
Console.WriteLine($"Writing: {destinationFile}");
}
}
private static BenchmarkRun LoadContainer(StorageClient client, string runStorageName)
{
var stream = new MemoryStream();
client.DownloadObject(BucketName, runStorageName, stream);
stream.Position = 0;
return(BenchmarkRun.Parser.ParseFrom(stream));
}
static void DownloadObject(string bucketName, string objectName, string filePath = null)
{
filePath = filePath ?? Path.GetFileName(objectName);
using (var stream = File.OpenWrite(filePath))
{
storageClient.DownloadObject(bucketName, objectName, stream);
}
Console.WriteLine($"{objectName}, {filePath} olarak indirildi.");
}
private void DownloadObject(StorageClient storage, string bucketName, string objectName, string localPath = null)
{
localPath = localPath ?? Path.GetFileName(objectName);
using (var outputFile = File.OpenWrite(localPath))
{
storage.DownloadObject(bucketName, objectName, outputFile);
}
Console.WriteLine($"downloaded {objectName} to {localPath}.");
}
internal static void ValidateData(string bucketName, string objectName, byte[] expectedData,
StorageClient client = null, DownloadObjectOptions options = null)
{
client = client ?? StorageClient.Create();
var downloaded = new MemoryStream();
client.DownloadObject(bucketName, objectName, downloaded, options);
Assert.Equal(expectedData, downloaded.ToArray());
}
public void DownloadObject(string bucketName, string objectName,
string localPath = null)
{
localPath ??= Path.GetFileName(objectName);
using (var outputFile = File.OpenWrite(localPath))
{
storageClient.DownloadObject(bucketName, objectName, outputFile);
}
Console.WriteLine($"GoogleBucket.cs - downloaded {objectName} to {localPath}.");
}
private async void DownloadTableData(string bucketName, string objectName)
{
var credential = GoogleCredential.FromFile(" enter credentials");
StorageClient storageClient = await StorageClient.CreateAsync(credential);
using (var fstream = new FileStream(Path.Combine(WebHostEnvironment.WebRootPath, "data", objectName), FileMode.Create))
{
storageClient.DownloadObject(bucketName, objectName, fstream);
}
}
public Stream CreateReadStream()
{
// Json config files are small, and will easily fit in memory.
var stream = new MemoryStream();
_storage.DownloadObject(_cloudStorageObject.Bucket,
_cloudStorageObject.Name, stream);
_logger.LogInformation("Loaded {0}/{1}", _cloudStorageObject.Bucket,
_cloudStorageObject.Name);
stream.Seek(0, SeekOrigin.Begin);;
return(stream);
}
private void DownloadPackage(string versionId, string localFileName)
{
if (File.Exists(localFileName))
{
File.Delete(localFileName);
}
using (var fileStream = File.OpenWrite(localFileName))
{
StorageClient.DownloadObject(Bucket, versionId, fileStream);
}
}
public void DownloadObject(string aBucketName, string aName, Stream aMemory)
{
try {
storage.DownloadObject(aBucketName, aName, aMemory);
}
catch (Google.GoogleApiException e)
when(e.Error.Code == 409)
{
// The bucket already exists. That's fine.
Console.WriteLine(e.Error.Message);
}
}
private static IList <BenchmarkEnvironment> LoadEnvironments(StorageClient client)
{
var environments = new List <BenchmarkEnvironment>();
var stream = new MemoryStream();
client.DownloadObject(BucketName, EnvironmentObjectName, stream);
stream.Position = 0;
while (stream.Position != stream.Length)
{
environments.Add(BenchmarkEnvironment.Parser.ParseDelimitedFrom(stream));
}
return(environments);
}
public void DownloadFile(string fileToDownload, StorageClient sc, string bn)
{
string objectName = fileToDownload;
string localPath = Directory.GetCurrentDirectory() + "\\" + Path.GetFileName(objectName);
using (var outputFile = File.OpenWrite(localPath))
{
sc.DownloadObject(bn, objectName, outputFile);
}
Debug.Log($"downloaded {objectName} to {localPath}.");
ScrollView.SetActive(false);
LoadFile(localPath);
}
public void LoadEnvironments()
{
environments.Clear();
var stream = new MemoryStream();
client.DownloadObject(bucketName, objectPrefix + EnvironmentObjectName, stream);
stream.Position = 0;
while (stream.Position != stream.Length)
{
environments.Add(BenchmarkEnvironment.Parser.ParseDelimitedFrom(stream));
}
environmentSaveRequired = false;
}
public void DownloadFile(string fileName, Stream destinationStream, string bucketName = "")
{
EnsureBucketExist(bucketName);
try
{
_storageClient.DownloadObject(_bucketName, fileName, destinationStream);
}
catch (GoogleApiException gex)
{
_logger.LogError(-1, gex, gex.Error.Message);
throw;
}
destinationStream.Seek(0, SeekOrigin.Begin);
}
public IActionResult GetImage([FromQuery] string name)
{
var stream = new MemoryStream();
try
{
stream.Position = 0;
var obj = _storageClient.GetObject("tenant-file-fc6de.appspot.com", name);
_storageClient.DownloadObject(obj, stream);
stream.Position = 0;
var response = File(stream, obj.ContentType, "file.png"); // FileStreamResult
return(response);
}
catch (Exception ex)
{
throw ex;
}
}
private static async Task downloadFilesGoogle()
{
var credential = GoogleCredential.FromFile(@"D:\Google_API_key_TFM.json");
StorageClient storageClient = await StorageClient.CreateAsync(credential);
storageClient.Service.HttpClient.Timeout = new TimeSpan(0, 10, 0);
var bucket = await storageClient.GetBucketAsync("bucket-ocr-tfm");
var blobList = storageClient.ListObjects(bucket.Name, "procesados/");
string strPath = @"D:\json\";
foreach (var outputOcr in blobList.Where(x => x.Name.Contains(".json")))
{
using (var stream = File.OpenWrite(strPath + outputOcr.Name.Split('/')[1]))
{
storageClient.DownloadObject(outputOcr, stream);
}
}
}
public async Task <string> LoadTextFileAsync(string filename)
{
Object item = _storageClient.GetObject(_configuration.BucketName, filename);
if (item != null)
{
using (Stream stream = new MemoryStream())
{
_storageClient.DownloadObject(item, stream);
stream.Position = 0;
using (var reader = new StreamReader(stream))
{
return(await reader.ReadToEndAsync());
}
}
}
return("");
}