/// <summary>
/// Uploads a stream to CloudFoundry via HTTP
/// </summary>
/// <param name="uploadUri">Uri to upload to</param>
/// <param name="zipStream">The compressed stream to upload</param>
/// <param name="resources">The json payload describing the files of the app</param>
/// <returns></returns>
private async Task <HttpResponseMessage> UploadZip(Uri uploadUri, Stream zipStream, string resources)
{
string boundary = DateTime.Now.Ticks.ToString("x");
using (SimpleHttpClient httpClient = new SimpleHttpClient(this.Client.CancellationToken, AppsEndpoint.DefaultUploadTimeout, this.Client.SkipCertificateValidation))
{
// http://apidocs.cloudfoundry.org/210/apps/uploads_the_bits_for_an_app.html
httpClient.HttpProxy = Client.HttpProxy;
httpClient.SkipCertificateValidation = Client.SkipCertificateValidation;
httpClient.Headers.Add("Authorization", string.Format("bearer {0}", this.Client.AuthorizationToken));
httpClient.Uri = uploadUri;
httpClient.Method = HttpMethod.Put;
List <HttpMultipartFormData> mpd = new List <HttpMultipartFormData>();
using (MemoryStream ms = new MemoryStream(Encoding.UTF8.GetBytes(resources)))
{
ms.Position = 0;
mpd.Add(new HttpMultipartFormData("resources", string.Empty, string.Empty, ms));
mpd.Add(new HttpMultipartFormData("application", "application.zip", "application/zip", zipStream));
HttpResponseMessage response = await httpClient.SendAsync(mpd);
return(response);
}
}
}
public FlatContainerChecker(
SimpleHttpClient simpleHttpClient,
string endpoint)
{
_simpleHttpClient = simpleHttpClient;
_endpoint = endpoint.TrimEnd('/');
}
public void SetUp()
{
unitTestContext = new UnitTestContext();
mtgStore = new MtgStore(
testConfig.Url,
testConfig.Database,
unitTestContext.QueryStatisticsStoreMock.Object,
unitTestContext.LoggingServiceMock.Object,
unitTestContext.SearchUtilityMock.Object);
unitTestContext.BotServicesMock.SetupGet(b => b.Store)
.Returns(mtgStore);
var httpClient = new SimpleHttpClient(unitTestContext.LoggingServiceMock.Object);
unitTestContext.BotServicesMock.SetupGet(b => b.HttpClient)
.Returns(httpClient);
plugin = new CardPricePlugin(
unitTestContext.BotServicesMock.Object,
unitTestContext.BotConfig);
plugin.LoggingService = unitTestContext.LoggingServiceMock.Object;
}
/// <summary>
/// Uploads a stream to CloudFoundry via HTTP
/// </summary>
/// <param name="uploadUri">Uri to upload to</param>
/// <param name="zipStream">The compressed stream to upload</param>
/// <param name="resources">The json payload describing the files of the app</param>
/// <returns></returns>
private async Task <SimpleHttpResponse> UploadZip(Uri uploadUri, Stream zipStream, string resources)
{
string boundary = DateTime.Now.Ticks.ToString("x");
using (SimpleHttpClient httpClient = new SimpleHttpClient(this.Client.CancellationToken))
{
httpClient.HttpProxy = Client.HttpProxy;
httpClient.SkipCertificateValidation = Client.SkipCertificateValidation;
httpClient.Headers.Add("Authorization", string.Format("bearer {0}", this.Client.AuthorizationToken));
httpClient.Uri = uploadUri;
httpClient.Method = HttpMethod.Post;
List <HttpMultipartFormData> mpd = new List <HttpMultipartFormData>();
using (MemoryStream ms = new MemoryStream(Encoding.UTF8.GetBytes(resources)))
{
ms.Position = 0;
mpd.Add(new HttpMultipartFormData("resources", string.Empty, string.Empty, ms));
mpd.Add(new HttpMultipartFormData("application", "app.zip", "application/zip", zipStream));
SimpleHttpResponse response = await httpClient.SendAsync(mpd);
return(response);
}
}
}
private void DeletePerson( object sender, RoutedEventArgs e )
{
Person person = this.uxPeople.SelectedItem as Person;
if ( person != null )
{
SimpleHttpClient client = new SimpleHttpClient( "http://localhost:1182/people" );
var query = client.CreateQuery<Person>().Delete( person.ID );
uxQueryText.Text = query.GetFullyQualifiedQuery( client ).ToString();
var task = query.ExecuteSingleAsync();
task.ContinueWith( t =>
{
Execute.OnUIThread( () =>
{
if ( !t.IsFaulted && t.IsCompleted && t.Result != null )
{
Debug.WriteLine( "Person: {0}", t.Result );
_people.Remove( _people.First( p => p.ID == t.Result.ID ) );
}
} );
} );
}
}
private void CreatePerson(object sender, RoutedEventArgs e)
{
Uri uri = new Uri("http://localhost:1182/people");
SimpleHttpClient client = new SimpleHttpClient(uri.ToString());
var person = new Person { ID = 0, Name = personName.Text };
var query = client.CreateQuery<Person>();
query.Create(person);
var task = query.ExecuteSingleAsync();
task.ContinueWith(t =>
{
Execute.OnUIThread(() =>
{
if (!t.IsFaulted && t.IsCompleted && t.Result != null)
{
Debug.WriteLine("Person: {0}", t.Result);
_people.Add(t.Result);
}
});
});
}
internal async Task <SimpleHttpResponse> SendAsync(SimpleHttpClient client, int expectedReturnStatus)
{
var result = await client.SendAsync();
if (((int)result.StatusCode) != expectedReturnStatus)
{
// Check if we can deserialize the response
CloudFoundryException cloudFoundryException;
try
{
string response = await result.Content.ReadAsStringAsync();
var exceptionObject = Utilities.DeserializeJson <CloudFoundryExceptionObject>(response);
cloudFoundryException = new CloudFoundryException(exceptionObject);
cloudFoundryException.Response = result;
throw cloudFoundryException;
}
catch (CloudFoundryException)
{
throw;
}
catch (Exception ex)
{
throw new CloudFoundryException(string.Format(CultureInfo.InvariantCulture, "An error occurred while talking to the server ({0})", result.StatusCode), ex);
}
}
return(result);
}
/// <inheritdoc/>
public async Task <List <RetrieveFileResponse> > RetrieveFile(Guid?app_guid, int?instance_index, string file_path)
{
List <RetrieveFileResponse> callResult = new List <RetrieveFileResponse>();
UriBuilder uriBuilder = new UriBuilder(this.Client.CloudTarget);
if (string.IsNullOrWhiteSpace(file_path))
{
uriBuilder.Path = string.Format(CultureInfo.InvariantCulture, "/v2/apps/{0}/instances/{1}/files", app_guid, instance_index);
}
else
{
uriBuilder.Path = string.Format(CultureInfo.InvariantCulture, "/v2/apps/{0}/instances/{1}/files/{2}", app_guid, instance_index, file_path);
}
using (SimpleHttpClient httpClient = new SimpleHttpClient(this.Client.CancellationToken, new TimeSpan(0, 5, 0), this.Client.SkipCertificateValidation))
{
httpClient.SkipCertificateValidation = Client.SkipCertificateValidation;
var authHeader = await BuildAuthenticationHeader();
if (!string.IsNullOrWhiteSpace(authHeader.Key))
{
httpClient.Headers.Add(authHeader);
}
httpClient.Uri = uriBuilder.Uri;
httpClient.Method = HttpMethod.Get;
var response = await httpClient.SendAsync();
var responseString = await response.Content.ReadAsStringAsync();
if (!uriBuilder.Path.EndsWith("/") && !uriBuilder.Path.EndsWith("files"))
{
callResult.Add(new RetrieveFileResponse()
{
FileContent = responseString
});
}
else
{
string[] instanceContent = responseString.Split(new string[] { "\r\n", "\n" }, StringSplitOptions.None);
foreach (string info in instanceContent)
{
if (string.IsNullOrWhiteSpace(info) == false)
{
string[] nameAndSize = info.Split(new string[] { " " }, StringSplitOptions.RemoveEmptyEntries);
callResult.Add(new RetrieveFileResponse()
{
FileName = nameAndSize[0].Trim(), FileSize = nameAndSize[1].Trim()
});
}
}
}
}
return(callResult);
}
public void GetTimeAsyncTest()
{
var client = new SimpleHttpClient();
var time = client.GetTimeAsync().Result;
Console.WriteLine("GetTimeAsync: " + time);
Assert.True(!string.IsNullOrEmpty(time));
}
public void GetTimeTest()
{
var client = new SimpleHttpClient();
var time = client.GetTime();
Console.WriteLine("GetTime: " + time);
Assert.True(string.IsNullOrEmpty(time));
}
public static bool Track(string[] pluginIds)
{
var trackRequest = new TrackRequest
{
PlayerHash = PlayerHash,
EnabledPluginIds = pluginIds
};
return(SimpleHttpClient.Post(TrackUri, trackRequest));
}
// GET: Endpoint
public ActionResult Process(string endpoint)
{
DataBaseConfigure dataBaseConfigure = _db.DB.First(b => b.endpoint == endpoint);
SimpleHttpClient simpleHttpClient = new SimpleHttpClient();
string url = dataBaseConfigure.url;
string plainText = simpleHttpClient.Get(url);
SlackResponse wrappedText = new SlackResponse(plainText);
return(Json(wrappedText, JsonRequestBehavior.AllowGet));
}
public ContentResult SiteVerify([FromBody] ReCaptchaModel model)
{
string reqData = string.Format(
"secret={0}&response={1}&remoteip={2}",
secret_key,
model.ReCaptchaResponse,
Request.HttpContext.Connection.RemoteIpAddress.ToString()
);
string resJson = SimpleHttpClient.PostAsync("https://www.google.com/recaptcha/api/siteverify", reqData, "application/x-www-form-urlencoded").Result;
return(Content(resJson, "application/json"));
}
void locator_DeviceStatusUpdate(object sender, DiscoveredEventArgs e)
{
SimpleHttpClient client = new SimpleHttpClient();
DeviceFactory factory = new DeviceFactory(client);
var device = factory.Create(new Uri(e.Device.Location));
if (device == null)
{
return;
}
devicesList.Add(device);
foundDevices.Enqueue(device);
}
protected override void Init(IDictionary <string, string> arguments, CancellationToken cancellationToken)
{
ServicePointManager.DefaultConnectionLimit = DegreeOfParallelism;
var verbose = arguments.GetOrDefault(Arguments.Verbose, false);
var packageStorageBase = arguments.GetOrThrow <string>(Arguments.ContentBaseAddress);
var failCacheTime = arguments.GetOrDefault(FailCacheTime, TimeSpan.FromHours(1));
var auxStorageFactory = CreateAuxStorageFactory(arguments, verbose);
var targetStorageFactory = CreateTargetStorageFactory(arguments, verbose);
var packageStorage = new AzureStorage(
storageBaseUri: new Uri(packageStorageBase),
maxExecutionTime: TimeSpan.FromMinutes(15),
serverTimeout: TimeSpan.FromMinutes(10),
useServerSideCopy: true,
compressContent: false,
verbose: true,
throttle: null);
var source = arguments.GetOrThrow <string>(Arguments.Source);
var iconProcessor = new IconProcessor(TelemetryService, LoggerFactory.CreateLogger <IconProcessor>());
var httpHandlerFactory = CommandHelpers.GetHttpMessageHandlerFactory(TelemetryService, verbose);
var httpMessageHandler = httpHandlerFactory();
var httpClient = new HttpClient(httpMessageHandler);
var simpleHttpClient = new SimpleHttpClient(httpClient, LoggerFactory.CreateLogger <SimpleHttpClient>());
var catalogClient = new CatalogClient(simpleHttpClient, LoggerFactory.CreateLogger <CatalogClient>());
var httpResponseProvider = new HttpClientWrapper(httpClient);
var externalIconProvider = new ExternalIconContentProvider(httpResponseProvider, LoggerFactory.CreateLogger <ExternalIconContentProvider>());
var iconCopyResultCache = new IconCopyResultCache(auxStorageFactory.Create(), failCacheTime, LoggerFactory.CreateLogger <IconCopyResultCache>());
var leafProcessor = new CatalogLeafDataProcessor(
packageStorage,
iconProcessor,
externalIconProvider,
iconCopyResultCache,
TelemetryService,
LoggerFactory.CreateLogger <CatalogLeafDataProcessor>());
_collector = new IconsCollector(
new Uri(source),
TelemetryService,
targetStorageFactory,
catalogClient,
leafProcessor,
iconCopyResultCache,
auxStorageFactory,
CommandHelpers.GetHttpMessageHandlerFactory(TelemetryService, verbose),
LoggerFactory.CreateLogger <IconsCollector>());
var cursorStorage = auxStorageFactory.Create();
_front = new DurableCursor(cursorStorage.ResolveUri("c2icursor.json"), cursorStorage, DateTime.MinValue.ToUniversalTime());
}
internal SimpleHttpClient GetHttpClient()
{
var httpClient = new SimpleHttpClient(this.Client.CancellationToken);
try
{
httpClient.HttpProxy = this.Client.HttpProxy;
httpClient.SkipCertificateValidation = this.Client.SkipCertificateValidation;
}
catch
{
httpClient.Dispose();
throw;
}
return(httpClient);
}
internal async Task <HttpResponseMessage> SendAsync(SimpleHttpClient client, int[] expectedReturnStatus)
{
var result = await client.SendAsync();
bool success = false;
foreach (int code in expectedReturnStatus)
{
if (((int)result.StatusCode) == code)
{
success = true;
break;
}
}
if (!success && !this.Client.UseStrictStatusCodeChecking)
{
success = IsSuccessStatusCode(result.StatusCode);
}
if (!success)
{
// Check if we can deserialize the response
CloudFoundryException cloudFoundryException;
try
{
string response = await result.Content.ReadAsStringAsync();
var exceptionObject = Utilities.DeserializeJson <CloudFoundryExceptionObject>(response);
cloudFoundryException = new CloudFoundryException(exceptionObject);
cloudFoundryException.Response = result;
throw cloudFoundryException;
}
catch (CloudFoundryException)
{
throw;
}
catch (Exception ex)
{
throw new CloudFoundryException(string.Format(CultureInfo.InvariantCulture, "An error occurred while talking to the server ({0})", result.StatusCode), ex);
}
}
return(result);
}
public static bool Consent(bool consent)
{
if (consent)
{
LogFile.WriteLine($"Registering player consent on the statistics server");
}
else
{
LogFile.WriteLine($"Withdrawing player consent, removing user data from the statistics server");
}
var consentRequest = new ConsentRequest()
{
PlayerHash = PlayerHash,
Consent = consent
};
return(SimpleHttpClient.Post(ConsentUri, consentRequest));
}
// This function may be called from another thread.
public static PluginStats DownloadStats()
{
if (!PlayerConsent.ConsentGiven)
{
MyLog.Default.WriteLine("Downloading plugin statistics anonymously...");
votingToken = null;
return(SimpleHttpClient.Get <PluginStats>(StatsUri));
}
MyLog.Default.WriteLine("Downloading plugin statistics, ratings and votes for " + PlayerHash);
var parameters = new Dictionary <string, string> {
["playerHash"] = PlayerHash
};
var pluginStats = SimpleHttpClient.Get <PluginStats>(StatsUri, parameters);
votingToken = pluginStats?.VotingToken;
return(pluginStats);
}
public static PluginStat Vote(string pluginId, int vote)
{
if (votingToken == null)
{
LogFile.WriteLine($"Voting token is not available, cannot vote");
return(null);
}
LogFile.WriteLine($"Voting {vote} on plugin {pluginId}");
var voteRequest = new VoteRequest
{
PlayerHash = PlayerHash,
PluginId = pluginId,
VotingToken = votingToken,
Vote = vote
};
var stat = SimpleHttpClient.Post <PluginStat, VoteRequest>(VoteUri, voteRequest);
return(stat);
}
/// <summary>
/// Uploads a stream to CloudFoundry via HTTP
/// </summary>
/// <param name="uploadUri">Uri to upload to</param>
/// <param name="zipStream">The compressed stream to upload</param>
/// <returns></returns>
private async Task <HttpResponseMessage> UploadZip(Uri uploadUri, Stream zipStream)
{
string boundary = DateTime.Now.Ticks.ToString("x");
using (SimpleHttpClient httpClient = new SimpleHttpClient(this.Client.CancellationToken, PackagesExperimentalEndpoint.DefaultUploadTimeout, this.Client.SkipCertificateValidation))
{
// http://apidocs.cloudfoundry.org/212/packages_(experimental)/upload_bits_for_a_package_of_type_bits.html
httpClient.HttpProxy = Client.HttpProxy;
httpClient.SkipCertificateValidation = Client.SkipCertificateValidation;
httpClient.Headers.Add("Authorization", string.Format("bearer {0}", this.Client.AuthorizationToken));
httpClient.Uri = uploadUri;
httpClient.Method = HttpMethod.Post;
List <HttpMultipartFormData> mpd = new List <HttpMultipartFormData>();
mpd.Add(new HttpMultipartFormData("bits", "application.zip", "application/zip", zipStream));
HttpResponseMessage response = await httpClient.SendAsync(mpd);
return(response);
}
}
internal SimpleHttpClient GetHttpClient(bool authenticate = true)
{
var httpClient = new SimpleHttpClient(this.Client.CancellationToken, this.Client.RequestTimeout, this.Client.SkipCertificateValidation);
try
{
httpClient.HttpProxy = this.Client.HttpProxy;
httpClient.SkipCertificateValidation = this.Client.SkipCertificateValidation;
if (authenticate)
{
httpClient.AddAuthentication(this.Client.AuthorizationToken);
}
}
catch
{
httpClient.Dispose();
throw;
}
return(httpClient);
}
static async Task MainAsync()
{
ServicePointManager.DefaultConnectionLimit = 64;
var idPattern = "Jver.TestPackage.IngestionTime4";
var versionPattern = "0.0.1-v{0}";
var testDuration = TimeSpan.FromMinutes(60);
var packageCount = 240;
var outputFile = $"results-{DateTimeOffset.UtcNow:yyyyMMddHHmmssFFFFFFF}.csv";
var pushEndpoint = "https://dev.nugettest.org/api/v2/package";
var apiKey = "";
var galleryEndpoints = new[]
{
"https://dev.nugettest.org",
};
var flatContainerEndpoints = new[]
{
"https://apidev.nugettest.org/v3-flatcontainer",
"https://nugetgallerydev.blob.core.chinacloudapi.cn/v3-flatcontainer"
};
var registrationEndpoints = new[]
{
"https://apidev.nugettest.org/v3/registration3",
"https://apidev.nugettest.org/v3/registration3-gz",
"https://apidev.nugettest.org/v3/registration3-gz-semver2",
"https://nugetgallerydev.blob.core.chinacloudapi.cn/v3-registration3",
"https://nugetgallerydev.blob.core.chinacloudapi.cn/v3-registration3-gz",
"https://nugetgallerydev.blob.core.chinacloudapi.cn/v3-registration3-gz-semver2",
};
var searchEndpoints = new[]
{
"https://nuget-dev-usnc-v2v3search.nugettest.org/query",
"https://nuget-dev-ussc-v2v3search.nugettest.org/query",
"https://nuget-dev-eastasia-search.nugettest.org/query",
"https://nuget-dev-southeastasia-search.nugettest.org/query",
};
var expandableSearchEndpoints = new string[0];
//var pushEndpoint = "https://int.nugettest.org/api/v2/package";
//var apiKey = "";
//var galleryEndpoints = new[]
//{
// "https://int.nugettest.org",
//};
//var flatContainerEndpoints = new[]
//{
// "https://apiint.nugettest.org/v3-flatcontainer",
//};
//var registrationEndpoints = new[]
//{
// "https://apiint.nugettest.org/v3/registration3",
// "https://apiint.nugettest.org/v3/registration3-gz",
// "https://apiint.nugettest.org/v3/registration3-gz-semver2",
//};
//var searchEndpoints = new[]
//{
// "http://localhost:21751/query",
//};
//var expandableSearchEndpoints = new[]
//{
// "https://nuget-usnc-v2v3search.int.nugettest.org/query",
// "https://nuget-ussc-v2v3search.int.nugettest.org/query",
//};
var loggerFactory = new LoggerFactory().AddConsole();
var httpClientHandler = new HttpClientHandler {
AutomaticDecompression = DecompressionMethods.GZip
};
var httpClient = new HttpClient(httpClientHandler);
var simpleHttpClient = new SimpleHttpClient(httpClient, loggerFactory.CreateLogger <SimpleHttpClient>());
var registrationClient = new RegistrationClient(simpleHttpClient);
var portTester = new PortTester();
var portDiscovery = new SimplePortDiscoverer(portTester);
var portExpander = new PortExpander(portDiscovery);
var packagePusher = new PackagePusher(httpClient, pushEndpoint);
var packageChecker = new PackageChecker(loggerFactory.CreateLogger <PackageChecker>());
var tester = new Tester(packageChecker, loggerFactory.CreateLogger <Tester>());
var endpointCheckers = new List <IEndpointChecker>();
endpointCheckers.AddRange(galleryEndpoints
.Select(endpoint => new GalleryChecker(httpClient, endpoint))
.ToList());
endpointCheckers.AddRange(flatContainerEndpoints
.Select(endpoint => new FlatContainerChecker(simpleHttpClient, endpoint))
.ToList());
endpointCheckers.AddRange(registrationEndpoints
.Select(endpoint => new RegistrationChecker(registrationClient, endpoint))
.ToList());
endpointCheckers.AddRange(searchEndpoints
.Select(endpoint => new SearchChecker(simpleHttpClient, endpoint))
.ToList());
endpointCheckers.AddRange(expandableSearchEndpoints
.Select(endpoint => new SearchChecker(simpleHttpClient, endpoint, portExpander))
.ToList());
var writeLock = new object();
AppendLine(writeLock, outputFile, GetCsvHeader(endpointCheckers));
var testParameters = new TestParameters
{
PackagePusher = packagePusher,
ApiKey = apiKey,
IdPattern = idPattern,
VersionPattern = versionPattern,
EndpointCheckers = endpointCheckers,
TestDuration = testDuration,
PackageCount = packageCount,
OnPackageResult = x => AppendResult(writeLock, outputFile, x),
};
var results = await tester.ExecuteAsync(testParameters);
Console.WriteLine(GetCsvHeader(endpointCheckers));
foreach (var result in results)
{
Console.WriteLine(GetCsvLine(result));
}
}
public void TestInitialize()
{
Logger = MockRepository.GenerateMock<ILogger>();
Client = MockRepository.GeneratePartialMock<SimpleHttpClient>("AnAPIKey", Logger);
Request = MockRepository.GenerateMock<WebRequestWrapper>();
Response = MockRepository.GenerateMock<WebResponseWrapper>();
ReqStream = new MemoryStream();
RespStream = new MemoryStream();
}
private void GetAllPeople(object sender, RoutedEventArgs e)
{
_people.Clear();
SimpleHttpClient client = new SimpleHttpClient("http://localhost:1182/people");
IHttpQueryProvider queryProvider = new HttpQueryProvider(client);
var query = new HttpQuery<Person>(queryProvider);
// query.ToString() == http://localhost:1182/people
//var query = new HttpQuery<Person>(new HttpQueryProvider(new SimpleHttpClient("http://localhost:1182")), /* resource name*/ "people");
//// query.ToString() == http://localhost:1182/people
//var query = new HttpQuery<Person>(queryProvider).Skip(5).Take(10);
//// query.ToString() == http://localhost:1182/people?$skip=5$top=10
//int id = 1;
//var query = new HttpQuery<Person>(queryProvider).Where(c => c.ID, id);
//// query.ToString() == http://localhost:1182/people?$filter=ID eq 1
//var query = new HttpQuery<Person>(null, /* resource name*/ "people");
//// query.ToString() == people
//var query = new HttpQuery<Person>(null, /* resource name*/ "people").Take(10);
//// query.ToString() == people?$top=10
uxQueryText.Text = query.GetFullyQualifiedQuery(client).ToString();
HandleQuery(query);
}
/// <summary>
/// Pushes an application to the cloud.
/// <remarks>
/// </remarks>
/// </summary>
/// <exception cref="NotImplementedException"></exception>
/// <param name="appGuid">Application guid</param>
/// <param name="appPath">Path of origin from which the application will be deployed</param>
/// <param name="stack">The name of the stack the app will be running on</param>
/// <param name="buildpackGitUrl">Git URL of the buildpack</param>
/// <param name="startApplication">True if the app should be started after upload is complete, false otherwise</param>
/// <param name="diskLimit">Memory limit used to stage package</param>
/// <param name="memoryLimit">Disk limit used to stage package</param>
public async Task Push(Guid appGuid, string appPath, string stack, string buildpackGitUrl, bool startApplication, int memoryLimit, int diskLimit)
{
if (appPath == null)
{
throw new ArgumentNullException("appPath");
}
IAppPushTools pushTools = new AppPushTools(appPath);
int usedSteps = 1;
// Step 1 - Check if application exists
this.TriggerPushProgressEvent(usedSteps, "Checking if application exists");
var app = await this.Client.AppsExperimental.GetApp(appGuid);
usedSteps += 1;
// Step 2 - Create package
var createPackage = new Model.Package(appGuid);
var packageResponse = await this.Client.PackagesExperimental.CreatePackage(createPackage);
Guid packageId = new Guid(packageResponse.guid.ToString());
if (this.CheckCancellation())
{
return;
}
usedSteps += 1;
// Step 3 - Zip all needed files and get a stream back from the PushTools
this.TriggerPushProgressEvent(usedSteps, "Creating zip package ...");
using (Stream zippedPayload = pushTools.GetZippedPayload(this.Client.CancellationToken))
{
if (this.CheckCancellation())
{
return;
}
usedSteps += 1;
// Step 4 - Upload zip to CloudFoundry ...
this.TriggerPushProgressEvent(usedSteps, "Uploading zip package ...");
await this.Client.PackagesExperimental.UploadBits(packageId, zippedPayload);
bool uploadProcessed = false;
while (!uploadProcessed)
{
var getPackage = await this.Client.PackagesExperimental.GetPackage(packageId);
Console.WriteLine(getPackage.state);
switch (getPackage.state)
{
case "FAILED":
{
throw new Exception(string.Format(CultureInfo.InvariantCulture, "Upload failed: {0}", getPackage.data["error"]));
}
case "READY":
{
uploadProcessed = true;
break;
}
default: continue;
}
if (this.CheckCancellation())
{
return;
}
Task.Delay(500).Wait();
}
usedSteps += 1;
}
var buildResponse = await this.Client.Builds.CreateBuild(packageId);
if (this.CheckCancellation())
{
return;
}
usedSteps += 1;
Guid dropLetGuid;
if (startApplication)
{
bool staged = false;
while (!staged)
{
var getBuild = await this.Client.Builds.GetBuild(buildResponse.guid.Value);
Console.WriteLine(getBuild.state);
switch (getBuild.state)
{
case "FAILED":
{
throw new Exception(string.Format(CultureInfo.InvariantCulture, "Staging failed: {0}", getBuild.error));
}
case "STAGED":
{
staged = true;
dropLetGuid = getBuild.droplet.guid.Value;
break;
}
default: continue;
}
if (this.CheckCancellation())
{
return;
}
Task.Delay(500).Wait();
}
//check droplets..
using (SimpleHttpClient httpClient = new SimpleHttpClient(this.Client.CancellationToken, new TimeSpan(0, 30, 0), true))
{
httpClient.SkipCertificateValidation = true;
httpClient.Headers.Add("Authorization", string.Format("bearer {0}", this.Client.AuthorizationToken));
httpClient.Uri = new Uri($"https://api.system.cf.singel.home/v3/apps/{appGuid}/droplets");
httpClient.Method = HttpMethod.Get;
//var fap = new { package = new { guid = packageId } };
HttpResponseMessage dropResponse = await httpClient.SendAsync();
var beun = dropResponse.Content.ReadAsStringAsync().Result;
}
// Step 6 - Assign droplet
//var assignRequest = new AssignDropletAsAppsCurrentDropletRequest(dropLetGuid);
var assignDroplet = await this.AssignDropletAsAppsCurrentDroplet(appGuid, dropLetGuid);
if (this.CheckCancellation())
{
return;
}
usedSteps += 1;
//create route
var routeRequest = new CreateRouteRequest();
routeRequest.Host = "test-route";
routeRequest.SpaceGuid = new Guid("ef1c944d-c7ec-4ceb-8177-317130a005da");
routeRequest.DomainGuid = new Guid("ff8129d7-6304-49da-8345-9c7317ac9d02");
var routeResponse = await this.Client.V2.Routes.CreateRoute(routeRequest);
//map route
// var mapRouteRequest = new MapRouteRequest();
// mapRouteRequest.RouteGuid = routeResponse.EntityMetadata.Guid;
await this.Client.V2.Routes.AssociateAppWithRoute(routeResponse.EntityMetadata.Guid, appGuid);
// Step 7 - Start Application
var response = await this.Client.AppsExperimental.StartingApp(appGuid);
if (this.CheckCancellation())
{
return;
}
usedSteps += 1;
}
// Step 8 - Done
this.TriggerPushProgressEvent(usedSteps, "Application {0} pushed successfully", app.name);
}
static async Task MainAsync()
{
const string connectionString = "DefaultEndpointsProtocol=https;AccountName=mystorageaccount;AccountKey=***";
const string cursorValue = "2019-04-29T12:19:24.1091293";
const string newBaseContainerName = "v3-registration4";
const string newBaseUrl = "https://mystorageaccount.blob.core.windows.net/" + newBaseContainerName;
ServicePointManager.DefaultConnectionLimit = 64;
var loggerFactory = new LoggerFactory().AddConsole();
var httpClientHandler = new HttpClientHandler
{
AutomaticDecompression = DecompressionMethods.Deflate | DecompressionMethods.GZip,
};
var httpClient = new HttpClient(httpClientHandler);
var simpleHttpClient = new SimpleHttpClient(httpClient, loggerFactory.CreateLogger <SimpleHttpClient>());
var registrationClient = new RegistrationClient(simpleHttpClient);
var copier = new RegistrationHiveCopier(
registrationClient,
simpleHttpClient,
loggerFactory.CreateLogger <RegistrationHiveCopier>());
var cloudBlobClient = new CloudBlobClientWrapper(connectionString, readAccessGeoRedundant: false);
var hives = new[]
{
new
{
OldBaseUrl = "https://api.nuget.org/v3/registration3",
NewBaseUrl = newBaseUrl,
NewContainerName = newBaseContainerName,
Gzip = false,
Cursor = true,
},
new
{
OldBaseUrl = "https://api.nuget.org/v3/registration3-gz",
NewBaseUrl = newBaseUrl + "-gz",
NewContainerName = newBaseContainerName + "-gz",
Gzip = true,
Cursor = true,
},
new
{
OldBaseUrl = "https://api.nuget.org/v3/registration3-gz-semver2",
NewBaseUrl = newBaseUrl + "-gz-semver2",
NewContainerName = newBaseContainerName + "-gz-semver2",
Gzip = true,
Cursor = false,
},
};
var ids = new[]
{
"DDPlanet.Logging",
"IBA.ECL.Services.Shared.Enums",
"Lith.FlatFile",
"Momentum.Pm.Api",
"Momentum.Pm.PortalApi",
"MSBuild.Obfuscar",
"Sensus",
"TIKSN-Framework",
"Vostok.ServiceDiscovery",
};
var hiveTasks = hives
.Select(async hive =>
{
await Task.Yield();
var container = cloudBlobClient.GetContainerReference(hive.NewContainerName);
await container.CreateIfNotExistAsync();
var idTasks = ids
.Select(async id =>
{
await Task.Yield();
await copier.CopyAsync(
container,
hive.OldBaseUrl,
hive.NewBaseUrl,
id,
hive.Gzip);
})
.ToList();
await Task.WhenAll(idTasks);
if (hive.Cursor)
{
var cursorBlob = container.GetBlobReference("cursor.json");
cursorBlob.Properties.ContentType = "application/json";
var cursorJObject = new JObject();
cursorJObject["value"] = cursorValue;
var cursorJson = cursorJObject.ToString(Formatting.Indented);
var cursorBytes = Encoding.UTF8.GetBytes(cursorJson);
using (var memoryStream = new MemoryStream(cursorBytes))
{
await cursorBlob.UploadFromStreamAsync(memoryStream, overwrite: true);
}
}
})
.ToList();
await Task.WhenAll(hiveTasks);
}
/// <summary>
/// Returns a LogMessage containing recent logs
/// </summary>
/// <param name="appGuid">The Cloud Foundry app unique identifier.</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <exception cref="System.ArgumentNullException">appGuid</exception>
/// <returns></returns>
public async Task <ApplicationLog[]> Recent(string appGuid, CancellationToken cancellationToken)
{
if (appGuid == null)
{
throw new ArgumentNullException("appGuid");
}
UriBuilder appLogUri = new UriBuilder(this.LoggregatorEndpoint);
if (appLogUri.Scheme == "ws")
{
appLogUri.Scheme = "http";
}
else
{
appLogUri.Scheme = "https";
}
appLogUri.Path = "recent";
appLogUri.Query = string.Format(CultureInfo.InvariantCulture, "app={0}", appGuid);
SimpleHttpClient client;
if (httpClient != null)
{
client = httpClient as SimpleHttpClient;
client.cancellationToken = cancellationToken;
}
else
{
client = new SimpleHttpClient(cancellationToken);
}
client.Uri = appLogUri.Uri;
client.Method = HttpMethod.Get;
client.Headers.Add("AUTHORIZATION", this.AuthenticationToken);
client.HttpProxy = this.HttpProxy;
client.SkipCertificateValidation = this.SkipCertificateValidation;
SimpleHttpResponse response = await client.SendAsync();
if (response.StatusCode != System.Net.HttpStatusCode.OK)
{
string errorMessage = await response.ReadContentAsStringAsync();
throw new LoggregatorException(string.Format(CultureInfo.InvariantCulture, "Server returned error code {0} with message: '{1}'", response.StatusCode, errorMessage));
}
MultipartMemoryStreamProvider multipart = null;
try
{
multipart = await response.Content.ReadAsMultipartAsync();
}
catch (IOException multipartException)
{
// There are no recent Logs. We need to investigate a better way for handling this
if (multipartException.Message.Contains("MIME multipart message is not complete"))
{
return(new ApplicationLog[] { new ApplicationLog()
{
Message = "(Server did not return any recent logs)"
} });
}
else
{
throw;
}
}
List <ApplicationLog> messages = new List <ApplicationLog>();
foreach (var msg in multipart.Contents)
{
messages.Add(this.protobufSerializer.DeserializeApplicationLog(await msg.ReadAsByteArrayAsync()));
}
return(messages.ToArray());
}
internal async Task <HttpResponseMessage> SendAsync(SimpleHttpClient client, int expectedReturnStatus)
{
int[] codes = new int[] { expectedReturnStatus };
return(await this.SendAsync(client, codes));
}
private void GetTop3People(object sender, RoutedEventArgs e)
{
_people.Clear();
SimpleHttpClient client = new SimpleHttpClient("http://localhost:1182/people");
var query = client.CreateQuery<Person>().Take(3);
uxQueryText.Text = query.GetFullyQualifiedQuery(client).ToString();
HandleQuery(query);
}
public DiscordApiClient(SimpleHttpClient httpClient, string clientId, string clientSecret)
{
_httpClient = httpClient;
_clientId = clientId;
_clientSecret = clientSecret;
}
private void GetPersonWithID(object sender, RoutedEventArgs e)
{
int id;
if (Int32.TryParse(this.uxPersonID.Text, out id))
{
_people.Clear();
SimpleHttpClient client = new SimpleHttpClient("http://localhost:1182/people");
var query = client.CreateQuery<Person>().Where(c => c.ID, id);
uxQueryText.Text = query.GetFullyQualifiedQuery(client).ToString();
HandleQuery(query);
}
}