public void DeserializeKeyPairCollection() { // this one is odd because even in the list, the items are wrapped with a root that needs to be unwrapped string json = JObject.Parse(@"{ 'keypairs': [ { 'keypair': { 'public_key': 'ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQDrBzodZLiWO6nIGGy9ZOVeFhbF6EaG8HUqrknNVKynH6+Hc5ToY71gmeQGJ7XZTAlyKKdFmPhNPCQCYqFQxjPKD3xTIAoGChlRHfkjYwjefbqxFswi9S0Fi3Lq8mawUVuPmPnuTr8KhL8ibnBbAxZnrcfTKBIoxhU+kN56CCmLnkJc5ouG/UcF+UpqUso45pYRf0YWANyyuafyCmj6NiDxMCGy/vnKUBLzMg8wQ01xGSGOfyGDIwuTFZpoPzjeqEV8oUGvxYt9Xyzh/pPKoOz1cz0wBDaVDpucTz3UEq65F9HhCmdwwjso8MP1K46LkM2JNQWQ0eTotqFvUJEoP2ff Generated-by-Nova', 'name': 'keypair-d20a3d59-9433-4b79-8726-20b431d89c78', 'fingerprint': 'ce:88:fe:6a:9e:c0:d5:91:08:8b:57:80:be:e6:ec:3d' } }, { 'keypair': { 'public_key': 'ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAAAgQDx8nkQv/zgGgB4rMYmIf+6A4l6Rr+o/6lHBQdW5aYd44bd8JttDCE/F/pNRr0lRE+PiqSPO8nDPHw0010JeMH9gYgnnFlyY3/OcJ02RhIPyyxYpv9FhY+2YiUkpwFOcLImyrxEsYXpD/0d3ac30bNH6Sw9JD9UZHYcpSxsIbECHw== Generated-by-Nova', 'name': 'uploaded-keypair', 'fingerprint': '1e:2c:9b:56:79:4b:45:77:f9:ca:7a:98:2c:b0:d5:3c' } } ] }").ToString(); var results = OpenStackNet.Deserialize <KeyPairSummaryCollection>(json); Assert.NotNull(results); Assert.Equal(2, results.Count()); var result = results.First(); Assert.Empty(((IHaveExtraData)result).Data); Assert.NotNull(result.PublicKey); }
public void DeserializeVolumeWithEmptyAttachment() { var json = JObject.Parse(@"{'volume': {'attachments': [{}]}}").ToString(); var result = OpenStackNet.Deserialize <Volume>(json); Assert.Empty(result.Attachments); }
static void Main(string[] args) { const string region = "RegionOne"; // Configure OpenStack.NET OpenStackNet.Configure(options => options.DefaultTimeout = TimeSpan.FromSeconds(5)); // Authenticate var identityUrl = new Uri("http://example.com"); var user = new CloudIdentityWithProject(); var identity = new OpenStackIdentityProvider(identityUrl, user); identity.Authenticate(); // Use legacy and new providers var legacyNetworking = new CloudNetworksProvider(null, identity); legacyNetworking.ListNetworks(); var networks = new NetworkingService(identity, region); networks.ListNetworks(); var legacyCompute = new CloudServersProvider(null, identity); legacyCompute.ListServers(); var compute = new ComputeService(identity, region); compute.ListServers(); }
/// <inheritdoc/> public override UserAccess GetUserAccess(CloudIdentity identity, bool forceCacheRefresh = false) { identity = identity ?? DefaultIdentity; CloudIdentityWithProject identityWithProject = identity as CloudIdentityWithProject; if (identityWithProject == null) { return(base.GetUserAccess(identityWithProject, forceCacheRefresh)); } if (string.IsNullOrEmpty(identityWithProject.Password)) { throw new NotSupportedException(string.Format("The {0} identity must specify a password.", typeof(CloudIdentityWithProject))); } if (!string.IsNullOrEmpty(identityWithProject.APIKey)) { throw new NotSupportedException(string.Format("The {0} identity does not support API key authentication.", typeof(CloudIdentityWithProject))); } Func <UserAccess> refreshCallback = () => { var projectId = identityWithProject.ProjectId != null?JToken.FromObject(identityWithProject.ProjectId) : string.Empty; JObject requestBody = new JObject( new JProperty("auth", new JObject( new JProperty("passwordCredentials", new JObject( new JProperty("username", JValue.CreateString(identityWithProject.Username)), new JProperty("password", JValue.CreateString(identityWithProject.Password)))), new JProperty("tenantName", JToken.FromObject(identityWithProject.ProjectName)), new JProperty("tenantId", projectId)))); var response = ExecuteRESTRequest <JObject>(identity, new Uri(UrlBase, "/v2.0/tokens"), HttpMethod.POST, requestBody, isTokenRequest: true); if (response == null || response.Data == null) { return(null); } // The defalut json serialization is helpfully formatting the expires date string. Use our custom serializer for this part to prevent chaos of timezone proportions. var rawJson = response.Data["access"]?.ToString(Formatting.None); if (rawJson == null) { return(null); } UserAccess access = OpenStackNet.Deserialize <UserAccess>(rawJson); if (access == null || access.Token == null) { return(null); } return(access); }; string key = string.Format("{0}:{1}/{2}", UrlBase, identityWithProject.ProjectId, identityWithProject.Username); var userAccess = TokenCache.Get(key, refreshCallback, forceCacheRefresh); return(userAccess); }
public void SerializeWhenNested() { var json = OpenStackNet.Serialize(new ThingCollection { new Thing() }); Assert.DoesNotContain("\"thing\"", json); }
public void DeserializeWhenNotRoot() { var json = JArray.Parse("[{'id':'thing-id'}]").ToString(); var things = OpenStackNet.Deserialize <List <Thing> >(json); Assert.Equal(1, things.Count); Assert.Equal("thing-id", things[0].Id); }
public void ShouldIgnoreUnexpectedRootProperties() { var json = JObject.Parse("{'links': [{'name': 'next', 'link': 'http://nextlink'}], 'thing': {'id': 'thing-id'}}").ToString(); var thing = OpenStackNet.Deserialize <Thing>(json); Assert.NotNull(thing); Assert.Equal("thing-id", thing.Id); }
public void SerializeWhenNotRoot() { var json = OpenStackNet.Serialize(new List <Thing> { new Thing() }); Assert.DoesNotContain("\"thing\"", json); }
public void DeserializeWhenNested() { var json = JObject.Parse("{'things':[{'id':'thing-id'}]}").ToString(); var things = OpenStackNet.Deserialize <ThingCollection>(json); Assert.NotNull(things); Assert.Equal(1, things.Count); Assert.Equal("thing-id", things[0].Id); }
/// <inheritdoc /> public new HttpTest RespondWithJson(int status, object data) { ResponseQueue.Enqueue(new HttpResponseMessage { StatusCode = (HttpStatusCode)status, Content = new CapturedJsonContent(OpenStackNet.Serialize(data)) }); return(this); }
public void DeserializeTimeToLiveFromSeconds() { var cache = new ServiceCache("cache", TimeSpan.FromSeconds(60)); var json = OpenStackNet.Serialize(cache); var result = OpenStackNet.Deserialize <ServiceCache>(json); Assert.Equal(60, result.TimeToLive.TotalSeconds); }
public void Deserialize() { var json = OpenStackNet.Serialize(new Thing { Id = "thing-id" }); var thing = OpenStackNet.Deserialize <Thing>(json); Assert.Equal("thing-id", thing.Id); }
public void Serialize() { var json = OpenStackNet.Serialize(new Thing()); var jsonObj = JObject.Parse(json); JProperty rootProperty = jsonObj.Properties().FirstOrDefault(); Assert.NotNull(rootProperty); Assert.Equal("thing", rootProperty.Name); }
public void SerializePageLink() { var link = new PageLink("next", "http://api.com/next"); string json = OpenStackNet.Serialize(link); var result = OpenStackNet.Deserialize <PageLink>(json); Assert.NotNull(result); Assert.True(result.IsNextPage); }
public void SerializeServerWithoutSchedulerHints() { string expectedJson = JObject.Parse(@"{'server':{'name':'name','imageRef':'00000000-0000-0000-0000-000000000000','flavorRef':'00000000-0000-0000-0000-000000000000'}}") .ToString(Formatting.None); var server = new ServerCreateDefinition("name", Guid.Empty, Guid.Empty); var json = OpenStackNet.Serialize(server); Assert.Equal(expectedJson, json); }
public void SerializeTimeToLiveToSeconds() { var cache = new ServiceCache("cache", TimeSpan.FromSeconds(60)); var json = OpenStackNet.Serialize(cache); var result = JObject.Parse(json); Assert.Equal(60, result.Value <double>("ttl")); }
public void WhenSerializingEmptyCollection_ItShouldBeIgnored() { var thing = new ExampleThing { Messages = new List <string>() }; string json = OpenStackNet.Serialize(thing); Assert.DoesNotContain("messages", json); }
/// <summary> /// Resets all configuration (Rackspace.NET, OpenStack.NET, Flurl and Json.NET) so that <see cref="Configure"/> can be called again. /// </summary> public static void ResetDefaults() { lock (ConfigureLock) { if (!_isConfigured) { return; } OpenStackNet.ResetDefaults(); _isConfigured = false; } }
/// <summary> /// Provides thread-safe accesss to Rackspace.NET's global configuration options. /// <para> /// Can only be called once at application start-up, before instantiating any Rackspace.NET objects. /// </para> /// </summary> /// <param name="configureFlurl">Addtional configuration of Flurl's global settings <seealso cref="FlurlHttp.Configure" />.</param> /// <param name="configureJson">Additional configuration of Json.NET's global settings <seealso cref="JsonConvert.DefaultSettings" />.</param> /// <param name="configure">Additional configuration of Rackspace.NET's global settings.</param> public static void Configure(Action <FlurlHttpConfigurationOptions> configureFlurl = null, Action <JsonSerializerSettings> configureJson = null, Action <RackspaceNetConfigurationOptions> configure = null) { if (configure != null) { lock (ConfigureLock) { configure(Configuration); } } Action <OpenStackNetConfigurationOptions> configureOpenStackNet = options => { Configuration.Apply(options); }; OpenStackNet.Configure(configureFlurl, configureJson, configureOpenStackNet); }
public void WhenDeserializingNullCollection_ItShouldUseAnEmptyCollection() { var thing = new ExampleThing { Messages = null }; string json = OpenStackNet.Serialize(thing); Assert.DoesNotContain("messages", json); var result = OpenStackNet.Deserialize <ExampleThing>(json); Assert.NotNull(result.Messages); Assert.Empty(result.Messages); }
public void Deserialize() { string json = JObject.Parse("{'port':{'extra_dhcp_opts':[{'opt_name':'a','opt_value':'stuff'},{'opt_name':'b','opt_value':'things'}]}}").ToString(Formatting.None); var result = OpenStackNet.Deserialize <PortCreateDefinition>(json).DHCPOptions; Assert.NotNull(result); Assert.Equal(2, result.Count); Assert.Contains("a", result.Keys); Assert.Contains("b", result.Keys); Assert.Equal("stuff", result["a"]); Assert.Equal("things", result["b"]); }
public void OpenStackNet_UsesDHCPOptionConverter() { var port = new Port { DHCPOptions = new Dictionary <string, string> { { "a", "stuff" } } }; var json = OpenStackNet.Serialize(port); var result = OpenStackNet.Deserialize <Port>(json); Assert.NotNull(result.DHCPOptions); Assert.Equal(1, result.DHCPOptions.Count); }
/// <summary> /// Provides thread-safe accesss to Rackspace.NET's global configuration options. /// <para> /// Can only be called once at application start-up, before instantiating any Rackspace.NET objects. /// </para> /// </summary> /// <param name="configureFlurl">Addtional configuration of Flurl's global settings <seealso cref="FlurlHttp.Configure" />.</param> /// <param name="configureJson">Additional configuration of Json.NET's global settings <seealso cref="JsonConvert.DefaultSettings" />.</param> /// <param name="configure">Additional configuration of Rackspace.NET's global settings.</param> public static void Configure(Action <FlurlHttpConfigurationOptions> configureFlurl = null, Action <JsonSerializerSettings> configureJson = null, Action <RackspaceNetConfigurationOptions> configure = null) { lock (ConfigureLock) { if (_isConfigured) { return; } OpenStackNet.Configure(configureFlurl, configureJson); configure?.Invoke(Configuration); Configuration.Apply(OpenStackNet.Configuration); _isConfigured = true; } }
public void Serialize() { var input = new PortCreateDefinition(null) { DHCPOptions = { { "a", "stuff" }, { "b", "things" } } }; string result = OpenStackNet.Serialize(input); string expectedJson = JObject.Parse("{'port':{'extra_dhcp_opts':[{'opt_name':'a','opt_value':'stuff'},{'opt_name':'b','opt_value':'things'}]}}").ToString(Formatting.None); Assert.Equal(expectedJson, result); }
public async Task UseBothOpenStackAndRackspace_RackspaceConfiguredFirst() { using (var httpTest = new HttpTest()) { RackspaceNet.Configure(); OpenStackNet.Configure(); await "http://api.com".GetAsync(); var userAgent = httpTest.CallLog[0].Request.Headers.UserAgent.ToString(); var rackspaceMatches = new Regex("rackspace").Matches(userAgent); Assert.Equal(1, rackspaceMatches.Count); var openstackMatches = new Regex("openstack").Matches(userAgent); Assert.Equal(1, openstackMatches.Count); } }
public void DeserializeSecurityGroupRule() { const string json = @"{ 'security_group_rule': { 'from_port': 22, 'group': {}, 'ip_protocol': 'tcp', 'to_port': 22, 'parent_group_id': 'bfa0c0ed-274b-4711-b3ee-37d35660fb06', 'ip_range': { 'cidr': '0.0.0.0 / 24' }, 'id': '55d75417-37df-48e2-96aa-20ba53a82900' }}"; var result = OpenStackNet.Deserialize <SecurityGroupRule>(JObject.Parse(json).ToString()); Assert.Equal("0.0.0.0 / 24", result.CIDR); }
public void SerializeServiceCollection() { var services = new ServiceCollection { Items = { new Service { Id = "service-id" } }, Links = { new PageLink("next", "http://api.com/next") } }; string json = OpenStackNet.Serialize(services); Assert.Contains("\"services\"", json); Assert.DoesNotContain("\"service\"", json); var result = OpenStackNet.Deserialize <ServiceCollection>(json); Assert.NotNull(result); Assert.Single(result); Assert.Single(result.Items); Assert.Single(result.Links); Assert.True(result.HasNextPage); }
public void WhenValueIsUnrecognized_AndDestinationIsNullable_UseNull() { var result = OpenStackNet.Deserialize <StuffStatus?>("\"bad-enum-value\""); Assert.Null(result); }
public void WhenValueIsUnrecognized_AndUnknownIsNotPresent_MatchToFirstValue() { var result = OpenStackNet.Deserialize <StuffStatus>("\"bad-enum-value\""); Assert.Equal(StuffStatus.Missing, result); }
public void WhenValueIsUnrecognized_MatchToUnknownValue() { var result = OpenStackNet.Deserialize <ThingStatus>("\"bad-enum-value\""); Assert.Equal(ThingStatus.Unknown, result); }