public override async Task RunAsync() { var user = await _armManager.GetUserAsync(); var functionApps = await _armManager.GetFunctionAppsAsync(await _armManager.GetCurrentSubscriptionAsync()); if (functionApps.Any()) { ColoredConsole.WriteLine(TitleColor("Function Apps:")); foreach (var app in functionApps) { ColoredConsole .WriteLine($" -> {TitleColor("Name")}: {app.SiteName} ({AdditionalInfoColor(app.Location)})") .WriteLine($" {TitleColor("Git Url")}: https://{user.PublishingUserName}@{app.SiteName}.scm.azurewebsites.net/") .WriteLine(); } } else { ColoredConsole.Error.WriteLine(ErrorColor(" -> No function apps found")); } }
private async Task SyncTriggers(Site functionApp) { await RetryHelper.Retry(async() => { ColoredConsole.WriteLine("Syncing triggers..."); HttpResponseMessage response = null; // This SyncTriggers function calls the endpoint for linux syncTriggers response = await AzureHelper.SyncTriggers(functionApp, AccessToken, ManagementURL); if (!response.IsSuccessStatusCode) { var errorMessage = $"Error calling sync triggers ({response.StatusCode}). "; // Add request ID if available var requestIds = response.Headers.GetValues("x-ms-correlation-request-id"); if (requestIds != null) { errorMessage += $"Request ID = '{string.Join(",", requestIds)}'."; } throw new CliException(errorMessage); } }, retryCount : 5); }
private async Task PublishRunFromZip(Site functionApp, Stream zipFile) { ColoredConsole.WriteLine("Preparing archive..."); var sas = await UploadZipToStorage(zipFile, functionApp.AzureAppSettings); functionApp.AzureAppSettings["WEBSITE_RUN_FROM_ZIP"] = sas; var result = await AzureHelper.UpdateFunctionAppAppSettings(functionApp, AccessToken); ColoredConsole.WriteLine("Upload completed successfully."); if (!result.IsSuccessful) { ColoredConsole .Error .WriteLine(ErrorColor("Error updating app settings:")) .WriteLine(ErrorColor(result.ErrorResult)); } else { ColoredConsole.WriteLine("Deployment completed successfully."); } }
private async Task InternalPublishFunctionApp(GitIgnoreParser ignoreParser) { ColoredConsole.WriteLine("Getting site publishing info..."); var functionApp = await _armManager.GetFunctionAppAsync(FunctionAppName); var functionAppRoot = ScriptHostHelpers.GetFunctionAppRootDirectory(Environment.CurrentDirectory); if (functionApp.IsLinux && !functionApp.IsDynamicLinux && RunFromZipDeploy) { ColoredConsole .WriteLine(ErrorColor("--zip is not supported with dedicated linux apps.")); } // if consumption linux, or --zip, run from zip else if (functionApp.IsDynamicLinux || RunFromZipDeploy) { await PublishRunFromZip(functionApp, functionAppRoot, ignoreParser); } else { await PublishZipDeploy(functionApp, functionAppRoot, ignoreParser); } // else same old same old }
public override Task RunAsync() { ColoredConsole.WriteLine(TitleColor("App Settings:")); foreach (var pair in _secretsManager.GetSecrets()) { ColoredConsole .WriteLine($" -> {TitleColor("Name")}: {pair.Key}") .WriteLine($" {TitleColor("Value")}: {(ShowValues ? pair.Value : "*****")}") .WriteLine(); } ColoredConsole.WriteLine(TitleColor("Connection Strings:")); foreach (var connectionString in _secretsManager.GetConnectionStrings()) { ColoredConsole .WriteLine($" -> {TitleColor("Name")}: {connectionString.Name}") .WriteLine($" {TitleColor("Value")}: {(ShowValues ? connectionString.Value : "*****")}") .WriteLine($" {TitleColor("ProviderName")}: {connectionString.ProviderName}") .WriteLine(); } return(Task.CompletedTask); }
private static async Task RestorePythonRequirementsPackapp(string functionAppRoot, string packagesLocation) { var packApp = Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), "tools", "python", "packapp"); var pythonExe = await ValidatePythonVersion(errorOutIfOld : true); var exe = new Executable(pythonExe, $"\"{packApp}\" --platform linux --python-version 36 --packages-dir-name {Constants.ExternalPythonPackages} \"{functionAppRoot}\" --verbose"); var sbErrors = new StringBuilder(); var exitCode = await exe.RunAsync(o => ColoredConsole.WriteLine(o), e => sbErrors.AppendLine(e)); if (exitCode != 0) { var errorMessage = "There was an error restoring dependencies. " + sbErrors.ToString(); // If --build-native-deps if required, we exit with this specific code to notify other toolings // If this exit code changes, partner tools must be updated if (exitCode == ExitCodes.BuildNativeDepsRequired) { ColoredConsole.WriteLine(ErrorColor(errorMessage)); Environment.Exit(ExitCodes.BuildNativeDepsRequired); } throw new CliException(errorMessage); } }
public override async Task RunAsync() { var storageAccounts = await _armManager.GetStorageAccountsAsync(); var storageAccount = storageAccounts.FirstOrDefault(st => st.StorageAccountName.Equals(StorageAccountName, StringComparison.OrdinalIgnoreCase)); if (storageAccount == null) { ColoredConsole .Error .WriteLine(ErrorColor($"Can't find storage account with name {StorageAccountName} in current subscription ({_settings.CurrentSubscription})")); } else { storageAccount = await _armManager.LoadAsync(storageAccount); var name = $"{storageAccount.StorageAccountName}_STORAGE"; _secretsManager.SetSecret(name, storageAccount.GetConnectionString()); ColoredConsole .WriteLine($"Secret saved locally in {SecretsManager.AppSettingsFileName} under name {ExampleColor(name)}.") .WriteLine(); } }
public IAction ChooseAction(Battle battle, Character character) { // This uses a menu-based approach. We create the choices from the menu, including their name, whether they are enabled, and // what action to pick if they are enabled and chosen. // After that, we display the menu and ask the user to make a selection. // If the selected option is enabled, use the action associated with it. List <MenuChoice> menuChoices = CreateMenuOptions(battle, character); for (int index = 0; index < menuChoices.Count; index++) { ColoredConsole.WriteLine($"{index + 1} - {menuChoices[index].Description}", menuChoices[index].Enabled ? ConsoleColor.Gray : ConsoleColor.DarkGray); } string choice = ColoredConsole.Prompt("What do you want to do?"); int menuIndex = Convert.ToInt32(choice) - 1; if (menuChoices[menuIndex].Enabled) { return(menuChoices[menuIndex].Action !); // Checking if it is enabled is as good as a null check. } return(new DoNothingAction()); // <-- This is actually fairly unforgiving. Typing in garbage or attempting to use a disabled option results in doing nothing. It would be better to try again. (Maybe that can be done as a Making It Your Own challenge. }
// https://stackoverflow.com/q/3404421/3234163 private static string InternalReadPassword() { var password = new StringBuilder(); while (true) { var key = Console.ReadKey(true); if (key.Key != ConsoleKey.Backspace && key.Key != ConsoleKey.Enter) { password.Append(key.KeyChar); ColoredConsole.Write("*"); } else if (key.Key == ConsoleKey.Backspace && password.Length > 0) { password.Remove(password.Length - 1, 1); ColoredConsole.Write("\b \b"); } else if (key.Key == ConsoleKey.Enter) { return(password.ToString()); } } }
static void Main(string[] args) { var actorSystem = ActorSystem.Create("ConsoleApp"); ColoredConsole.WriteLineGreen($"{actorSystem.Name} Actor System Created."); /* * // start the Application Actors * // var consoleUi = actorSystem.ActorOf<ConsoleUiActor>("ConsoleUi"); * var consoleUi = actorSystem.ActorOf(Props.Create<ConsoleUiActor>(), "ConsoleUi"); * consoleUi.Tell("start"); */ actorSystem.Terminate(); // wait for the actor system to terminate ColoredConsole.WriteLine("Awaiting for ActorSystem Termination."); actorSystem.WhenTerminated.Wait(); ColoredConsole.WriteLine("ActorSystem Terminated."); ColoredConsole.WriteLine("Press 'enter' to exit."); Console.ReadLine(); }
public static async Task <DeployStatus> WaitForDedicatedBuildToComplete(HttpClient client, Site functionApp) { // There is a tracked Locking issue in kudulite causing Race conditions, so we have to use this API // to gather deployment progress. ColoredConsole.Write("Remote build in progress, please wait"); while (true) { var json = await InvokeRequest <IDictionary <string, bool> >(client, HttpMethod.Get, "/api/isdeploying"); bool isDeploying = json["value"]; if (!isDeploying) { string deploymentId = await GetLatestDeploymentId(client, functionApp, restrictedToken : null); DeployStatus status = await GetDeploymentStatusById(client, functionApp, restrictedToken : null, id : deploymentId); ColoredConsole.Write($"done{Environment.NewLine}"); return(status); } ColoredConsole.Write("."); await Task.Delay(5000); } }
private void SetConnectionStringAndTaskHubName() { // Set connection string key and task hub name to defaults _connectionStringKey = DefaultConnectionStringKey; _taskHubName = DefaultTaskHubName; try { if (File.Exists(ScriptConstants.HostMetadataFileName)) { // Attempt to retrieve Durable override settings from host.json dynamic hostSettings = JObject.Parse(File.ReadAllText(ScriptConstants.HostMetadataFileName)); string version = hostSettings["version"]; if (version?.Equals("2.0") == true) { // If the version is (explicitly) 2.0, prepend path to 'durableTask' with 'extensions' _connectionStringKey = hostSettings?.extensions?.durableTask?.AzureStorageConnectionStringName ?? _connectionStringKey; _taskHubName = hostSettings?.extensions?.durableTask?.HubName ?? _taskHubName; } else { _connectionStringKey = hostSettings?.durableTask?.AzureStorageConnectionStringName ?? _connectionStringKey; _taskHubName = hostSettings?.durableTask?.HubName ?? _taskHubName; } } else { ColoredConsole.WriteLine(Yellow($"Could not find local host metadata file '{ScriptConstants.HostMetadataFileName}'")); } } catch (Exception e) { ColoredConsole.WriteLine(Yellow($"Exception thrown while attempting to parse override connection string and task hub name from '{ScriptConstants.HostMetadataFileName}':")); ColoredConsole.WriteLine(Yellow(e.Message)); } }
public void Run() { var start = head; var end = tail; while (end != null && !string.IsNullOrWhiteSpace(parser.TargetToRun) && !end.Name.Equals(parser.TargetToRun, StringComparison.OrdinalIgnoreCase)) { end = end.Previous; } if (end == null) { ColoredConsole.Error.WriteLine("No target was found to start".Red()); return; } PrintTargetsToRun(start, end); while (start != null) { if (!start.Skip) { ColoredConsole.WriteLine($"Executing target:{start.Name}".Cyan()); start.Target(); ColoredConsole.WriteLine($"Finished executing target:{start.Name}".DarkCyan()); } if (start == end) { break; } start = start.Next; } }
public override async Task RunAsync() { if (SourceControl != SourceControl.Git) { throw new Exception("Only Git is supported right now for vsc"); } if (!string.IsNullOrEmpty(FolderName)) { var folderPath = Path.Combine(Environment.CurrentDirectory, FolderName); FileSystemHelpers.EnsureDirectory(folderPath); Environment.CurrentDirectory = folderPath; } var language = string.Empty; if (string.IsNullOrEmpty(Language)) { ColoredConsole.Write("Select a language: "); language = SelectionMenuHelper.DisplaySelectionWizard(availableLanguages.Keys); ColoredConsole.WriteLine(TitleColor(language)); } else { language = Language; } language = NormalizeLanguage(language); await InitLanguageSpecificArtifacts(language); await WriteFiles(); await WriteLocalSettingsJson(language); await WriteExtensionsJson(); await SetupSourceControl(); await WriteDockerfile(language); PostInit(); }
public static void Zip() { var version = CurrentVersion; foreach (var runtime in Settings.TargetRuntimes) { var path = Path.Combine(Settings.OutputDir, runtime); var zipPath = Path.Combine(Settings.OutputDir, $"Azure.Functions.Cli.{runtime}.{version}.zip"); ColoredConsole.WriteLine($"Creating {zipPath}"); ZipFile.CreateFromDirectory(path, zipPath, CompressionLevel.Optimal, includeBaseDirectory: false); var shaPath = $"{zipPath}.sha2"; ColoredConsole.WriteLine($"Creating {shaPath}"); File.WriteAllText(shaPath, ComputeSha256(zipPath)); try { Directory.Delete(path, recursive: true); } catch { ColoredConsole.Error.WriteLine($"Error deleting {path}"); } ColoredConsole.WriteLine(); } string ComputeSha256(string file) { using (var fileStream = File.OpenRead(file)) { var sha1 = new SHA256Managed(); return(BitConverter.ToString(sha1.ComputeHash(fileStream)).Replace("-", string.Empty).ToLower()); } } }
private static void Main() { Log.Assign(new ConsoleLog(typeof(Program)) { LogLevel = LogLevel.Trace }); new ConnectionStringService().Approve(); var subscriptionManager = SubscriptionManager.Default(); subscriptionManager.Subscribe(new[] { typeof(WorkDoneEvent).FullName }); var bus = ServiceBus .Create(c => c.SubscriptionManager(subscriptionManager)) .Start(); Console.WriteLine(); ColoredConsole.WriteLine(ConsoleColor.Green, "Client bus started. Press CTRL+C to stop."); Console.WriteLine(); ColoredConsole.WriteLine(ConsoleColor.Green, "Press enter to publish an OrderCompleted event."); Console.WriteLine(); while (true) { Console.ReadLine(); var message = new OrderCompletedEvent { OrderId = Guid.NewGuid() }; bus.Publish(message); Console.WriteLine("Published OrderCompleted Id: {0}", message.OrderId); } }
public static async Task EnsureVirtualEnvrionmentIgnored() { if (InVirtualEnvironment) { try { var virtualEnvName = Path.GetFileNameWithoutExtension(VirtualEnvironmentPath); if (FileSystemHelpers.DirectoryExists(Path.Join(Environment.CurrentDirectory, virtualEnvName))) { var funcIgnorePath = Path.Join(Environment.CurrentDirectory, Constants.FuncIgnoreFile); // If .funcignore exists and already has the venv name, we are done here if (FileSystemHelpers.FileExists(funcIgnorePath)) { var rawfuncIgnoreContents = await FileSystemHelpers.ReadAllTextFromFileAsync(funcIgnorePath); if (rawfuncIgnoreContents.Contains(Environment.NewLine + virtualEnvName)) { return; } } // Write the current env to .funcignore ColoredConsole.WriteLine($"Writing {Constants.FuncIgnoreFile}"); using (var fileStream = FileSystemHelpers.OpenFile(funcIgnorePath, FileMode.Append, FileAccess.Write)) using (var streamWriter = new StreamWriter(fileStream)) { await streamWriter.WriteAsync(Environment.NewLine + virtualEnvName); await streamWriter.FlushAsync(); } } } catch (Exception) { // Safe execution, we aren't harmed by failures here } } }
public override async Task RunAsync() { await PreRunConditions(); if (VerboseLogging.HasValue && VerboseLogging.Value) { Utilities.PrintLogo(); } Utilities.PrintVersion(); ScriptApplicationHostOptions hostOptions = SelfHostWebHostSettingsFactory.Create(Environment.CurrentDirectory); ValidateAndBuildHostJsonConfigurationIfFileExists(hostOptions); (var listenUri, var baseUri, var certificate) = await Setup(); IWebHost host = await BuildWebHost(hostOptions, listenUri, baseUri, certificate); var runTask = host.RunAsync(); var hostService = host.Services.GetRequiredService <WebJobsScriptHostService>(); await hostService.DelayUntilHostReady(); var scriptHost = hostService.Services.GetRequiredService <IScriptJobHost>(); var httpOptions = hostService.Services.GetRequiredService <IOptions <HttpOptions> >(); if (scriptHost != null && scriptHost.Functions.Any()) { DisplayFunctionsInfoUtilities.DisplayFunctionsInfo(scriptHost.Functions, httpOptions.Value, baseUri); } if (VerboseLogging == null || !VerboseLogging.Value) { ColoredConsole.WriteLine(AdditionalInfoColor("For detailed output, run func with --verbose flag.")); } await runTask; }
public override async Task RunAsync() { var functionApp = await _armManager.GetFunctionAppAsync(FunctionAppName); var basicHeaderValue = Convert.ToBase64String(Encoding.UTF8.GetBytes($"{functionApp.PublishingUserName}:{functionApp.PublishingPassword}")); using (var client = new HttpClient()) { client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Basic", basicHeaderValue); var response = await client.GetStreamAsync(new Uri($"https://{functionApp.ScmUri}/api/logstream/application")); using (var reader = new StreamReader(response)) { var buffer = new char[4096]; var count = 0; do { count = await reader.ReadAsync(buffer, 0, buffer.Length); ColoredConsole.Write(new string(buffer.Take(count).ToArray())); } while (count != 0); } } }
public override async Task RunAsync() { var workerRuntime = WorkerRuntimeLanguageHelper.GetCurrentWorkerRuntimeLanguage(_secretsManager); if (workerRuntime == WorkerRuntime.None) { ColoredConsole.WriteLine(WarningColor("your worker runtime is not set. As of 2.0.1-beta.26 a worker runtime setting is required.")) .WriteLine(WarningColor($"Please run `{AdditionalInfoColor($"func settings add {Constants.FunctionsWorkerRuntime} <option>")}` or add {Constants.FunctionsWorkerRuntime} to your local.settings.json")) .WriteLine(WarningColor($"Available options: {WorkerRuntimeLanguageHelper.AvailableWorkersRuntimeString}")); } await PreRunConditions(workerRuntime); Utilities.PrintLogo(); Utilities.PrintVersion(); var settings = SelfHostWebHostSettingsFactory.Create(Environment.CurrentDirectory); (var listenUri, var baseUri, var certificate) = await Setup(); IWebHost host = await BuildWebHost(settings, workerRuntime, listenUri, certificate); var runTask = host.RunAsync(); var hostService = host.Services.GetRequiredService <WebJobsScriptHostService>(); await hostService.DelayUntilHostReady(); var scriptHost = hostService.Services.GetRequiredService <IScriptJobHost>(); var httpOptions = hostService.Services.GetRequiredService <IOptions <HttpOptions> >(); DisplayHttpFunctionsInfo(scriptHost, httpOptions.Value, baseUri); DisplayDisabledFunctions(scriptHost); await runTask; }
public static void Zip() { var version = CurrentVersion; foreach (var runtime in Settings.TargetRuntimes) { var path = Path.Combine(Settings.OutputDir, runtime); var zipPath = Path.Combine(Settings.OutputDir, $"Azure.Functions.Cli.{runtime}.{version}.zip"); ColoredConsole.WriteLine($"Creating {zipPath}"); ZipFile.CreateFromDirectory(path, zipPath, CompressionLevel.Optimal, includeBaseDirectory: false); try { Directory.Delete(path, recursive: true); } catch { ColoredConsole.Error.WriteLine($"Error deleting {path}"); } ColoredConsole.WriteLine(); } }
public void PrintId() { try { var block73 = ReadBlock(0x73); var block7F = ReadBlock(0x7F); Console.WriteLine(); Console.WriteLine($"Memory Size: {block73[1]}"); Console.WriteLine($"Owner: '{ExtractString(block73, 0x30, 16)}'"); Console.WriteLine(ExtractString(block7F, 0xBD, 15)); Console.WriteLine(ExtractString(block7F, 0xCD, 15)); Console.WriteLine(ExtractString(block7F, 0xDD, 15)); Console.WriteLine(ExtractString(block7F, 0xED, 15)); } catch (TimeoutException e) { using (var coloredConsole = new ColoredConsole(ConsoleColor.Red)) { Console.Error.WriteLine($"ERROR: {e.Message}"); } Console.WriteLine("The transmitter does not repond to a connection request. Check the connection, or try to power-cycle the transmitter."); } }
public async Task PublishZipDeploy(Site functionApp, Func <Task <Stream> > zipFileFactory) { await RetryHelper.Retry(async() => { using (var client = GetRemoteZipClient(new Uri($"https://{functionApp.ScmUri}"))) using (var request = new HttpRequestMessage(HttpMethod.Post, new Uri("api/zipdeploy", UriKind.Relative))) { request.Headers.IfMatch.Add(EntityTagHeaderValue.Any); ColoredConsole.WriteLine("Creating archive for current directory..."); request.Content = CreateStreamContentZip(await zipFileFactory()); ColoredConsole.WriteLine("Uploading archive..."); var response = await client.SendAsync(request); if (!response.IsSuccessStatusCode) { throw new CliException($"Error uploading archive ({response.StatusCode})."); } ColoredConsole.WriteLine("Upload completed successfully."); } }, 2); }
private async Task PreRunConditions(WorkerRuntime workerRuntime) { if (workerRuntime == WorkerRuntime.python) { // We need to update the PYTHONPATH to add worker's dependencies var pythonPath = Environment.GetEnvironmentVariable("PYTHONPATH") ?? string.Empty; var pythonWorkerDeps = Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), "workers", "python", "deps"); if (!pythonPath.Contains(pythonWorkerDeps)) { Environment.SetEnvironmentVariable("PYTHONPATH", $"{pythonWorkerDeps}{Path.PathSeparator}{pythonPath}", EnvironmentVariableTarget.Process); } if (StaticSettings.IsDebug) { ColoredConsole.WriteLine($"PYTHONPATH for the process is: {Environment.GetEnvironmentVariable("PYTHONPATH")}"); } } else if (workerRuntime == WorkerRuntime.dotnet && !NoBuild) { if (DotnetHelpers.CanDotnetBuild()) { var outputPath = Path.Combine("bin", "output"); await DotnetHelpers.BuildDotnetProject(outputPath, string.Empty); Environment.CurrentDirectory = Path.Combine(Environment.CurrentDirectory, outputPath); } else if (StaticSettings.IsDebug) { ColoredConsole.WriteLine("Could not find a valid .csproj file. Skipping the build."); } } if (!NetworkHelpers.IsPortAvailable(Port)) { throw new CliException($"Port {Port} is unavailable. Close the process using that port, or specify another port using --port [-p]."); } }
private async Task SyncTriggers(Site functionApp) { if (functionApp.IsDynamic) { ColoredConsole.WriteLine("Syncing triggers..."); HttpResponseMessage response = null; if (functionApp.IsLinux) { response = await _armManager.SyncTriggers(functionApp); } else { using (var client = await GetRemoteZipClient(new Uri($"https://{functionApp.ScmUri}"))) { response = await client.PostAsync("api/functions/synctriggers", content : null); } } if (!response.IsSuccessStatusCode) { throw new CliException($"Error calling sync triggers ({response.StatusCode})."); } } }
public override async Task RunAsync() { Utilities.PrintLogo(); var settings = SelfHostWebHostSettingsFactory.Create(Environment.CurrentDirectory); (var baseAddress, var certificate) = Setup(); IWebHost host = await BuildWebHost(settings, baseAddress, certificate); var runTask = host.RunAsync(); var manager = host.Services.GetRequiredService <WebScriptHostManager>(); await manager.DelayUntilHostReady(); ColoredConsole.WriteLine($"Listening on {baseAddress}"); ColoredConsole.WriteLine("Hit CTRL-C to exit..."); DisplayHttpFunctionsInfo(manager, baseAddress); DisplayDisabledFunctions(manager); await SetupDebuggerAsync(baseAddress); await runTask; }
public async Task Deploy(string Name, Template template) { var path = Path.Combine(Environment.CurrentDirectory, Name); if (FileSystemHelpers.DirectoryExists(path)) { var response = "n"; do { ColoredConsole.Write("A directory with the name {Name} already exists. Overwrite [y/n]? [n] "); response = Console.ReadLine(); } while (response != "n" && response != "y"); if (response == "n") { return; } } if (FileSystemHelpers.DirectoryExists(path)) { FileSystemHelpers.DeleteDirectorySafe(path, ignoreErrors: false); } FileSystemHelpers.EnsureDirectory(path); foreach (var file in template.Files) { var filePath = Path.Combine(path, file.Key); ColoredConsole.WriteLine($"Writing {filePath}"); await FileSystemHelpers.WriteAllTextToFileAsync(filePath, file.Value); } var functionJsonPath = Path.Combine(path, "function.json"); ColoredConsole.WriteLine($"Writing {functionJsonPath}"); await FileSystemHelpers.WriteAllTextToFileAsync(functionJsonPath, JsonConvert.SerializeObject(template.Function, Formatting.Indented)); }
public async Task <bool> RequireDatabaseUpdate(PhotoId photoId, CancellationToken ct) { var(flickrId, title) = photoId; try { var photo = await _photoRepository.GetByHostingId(flickrId); if (photo == null) { return(true); } // ColoredConsole.WriteLine("already saved: " + JsonSerializer.Serialize(photo), Colors.txtWarning); // todo: detect if caption is changed and the reupload is required. return(false); } catch (Exception e) { ColoredConsole.WriteLine($"{e}", Colors.bgDanger); return(false); } }
public override int Read() { var int32_1 = BigEndianBitConverter.ToInt32(fileData, iPos); iPos += 4; BigEndianBitConverter.ToInt32(fileData, iPos); iPos += 4; for (var index = 0; index < int32_1; ++index) { iPos += 4; iPos += 4; iPos += 4; iPos += 4; iPos += 4; iPos += 375; var int32_2 = BigEndianBitConverter.ToInt32(fileData, iPos); iPos += 4; iPos += 20; var int32_3 = BigEndianBitConverter.ToInt32(fileData, iPos); iPos += 4; iPos += 486; var int16 = BigEndianBitConverter.ToInt16(fileData, iPos); iPos += 2; var name = readString((int)int16); var int32_4 = BigEndianBitConverter.ToInt32(fileData, iPos); iPos += 4; iPos += int32_4 * 200; var int32_5 = BigEndianBitConverter.ToInt32(fileData, iPos); iPos += 4; iPos += int32_5 * 3; iPos += 111; ColoredConsole.WriteLineInfo("{0:x8} {4:0000} {1} --> Tex: {2}; Norm: {3}", (object)iPos, (object)name, (object)int32_2, (object)int32_3, (object)index); Materials.Add(new Material(name, int32_2, int32_3)); } return(iPos); }
private void DisplayHttpFunctionsInfo(WebScriptHostManager hostManager, Uri baseUri) { if (hostManager != null) { var httpFunctions = hostManager.Instance.Functions.Where(f => f.Metadata.IsHttpFunction()); if (httpFunctions.Any()) { ColoredConsole .WriteLine() .WriteLine(Yellow("Http Functions:")) .WriteLine(); } foreach (var function in httpFunctions) { var binding = function.Metadata.Bindings.FirstOrDefault(b => b.Type != null && b.Type.Equals("httpTrigger", StringComparison.OrdinalIgnoreCase)); var httpRoute = binding?.Raw?.GetValue("route", StringComparison.OrdinalIgnoreCase)?.ToString(); httpRoute = httpRoute ?? function.Name; var extensions = hostManager.Instance.ScriptConfig.HostConfig.GetService <IExtensionRegistry>(); var httpConfig = extensions.GetExtensions <IExtensionConfigProvider>().OfType <HttpExtensionConfiguration>().Single(); string hostRoutePrefix = ""; if (!function.Metadata.IsProxy) { hostRoutePrefix = httpConfig.RoutePrefix ?? "api/"; hostRoutePrefix = string.IsNullOrEmpty(hostRoutePrefix) || hostRoutePrefix.EndsWith("/") ? hostRoutePrefix : $"{hostRoutePrefix}/"; } var url = $"{baseUri.ToString().Replace("0.0.0.0", "localhost")}{hostRoutePrefix}{httpRoute}"; ColoredConsole .WriteLine($"\t{Yellow($"{function.Name}:")} {Green(url)}") .WriteLine(); } } }