Example #1
0
        public static async Async.Task <Network> Create(string region, ICreds creds, IConfigOperations configOperations, ISubnet subnet)
        {
            var group          = creds.GetBaseResourceGroup();
            var instanceConfig = await configOperations.Fetch();

            var networkConfig = instanceConfig.NetworkConfig;

            // Network names will be calculated from the address_space/subnet
            // *except* if they are the original values.  This allows backwards
            // compatibility to existing configs if you don't change the network
            // configs.

            string name;

            if (networkConfig.AddressSpace == NetworkConfig.Default.AddressSpace && networkConfig.Subnet == NetworkConfig.Default.Subnet)
            {
                name = region;
            }
            else
            {
                var networkId = Faithlife.Utility.GuidUtility.Create(NETWORK_GUID_NAMESPACE, string.Join("|", networkConfig.AddressSpace, networkConfig.Subnet), 5);
                name = $"{region}-{networkId}";
            }


            return(new Network(region, group, name, networkConfig, subnet));
        }
Example #2
0
    public async Async.Task <IList <VirtualMachineScaleSetExtensionData> > GenericExtensions(string region, Os vmOs)
    {
        var extensions = new List <VirtualMachineScaleSetExtensionData>();

        var instanceConfig = await _instanceConfigOps.Fetch();

        extensions.Add(await MonitorExtension(region, vmOs));

        var depenency = DependencyExtension(region, vmOs);

        if (depenency is not null)
        {
            extensions.Add(depenency);
        }

        if (instanceConfig.Extensions is not null)
        {
            if (instanceConfig.Extensions.Keyvault is not null)
            {
                var keyvault = KeyVaultExtension(region, instanceConfig.Extensions.Keyvault, vmOs);
                extensions.Add(keyvault);
            }

            if (instanceConfig.Extensions.Geneva is not null && vmOs == Os.Windows)
            {
                var geneva = GenevaExtension(region);
                extensions.Add(geneva);
            }

            if (instanceConfig.Extensions.AzureMonitor is not null && vmOs == Os.Linux)
            {
                var azMon = AzMonExtension(region, instanceConfig.Extensions.AzureMonitor);
                extensions.Add(azMon);
            }

            if (instanceConfig.Extensions.AzureSecurity is not null && vmOs == Os.Linux)
            {
                var azSec = AzSecExtension(region);
                extensions.Add(azSec);
            }
        }

        return(extensions);
    }
        public async Task <HttpResponseData> Get([HttpTrigger(AuthorizationLevel.Anonymous, "get", Route = "testhooks/instance-config")] HttpRequestData req)
        {
            _log.Info("Fetching instance config");
            var config = await _configOps.Fetch();

            if (config is null)
            {
                _log.Error("Instance config is null");
                Error err  = new(ErrorCode.INVALID_REQUEST, new[] { "Instance config is null" });
                var   resp = req.CreateResponse(HttpStatusCode.InternalServerError);
                await resp.WriteAsJsonAsync(err);

                return(resp);
            }
            else
            {
                var str = EntityConverter.ToJsonString(config);

                var resp = req.CreateResponse(HttpStatusCode.OK);
                await resp.WriteStringAsync(str);

                return(resp);
            }
        }