public void Should_Authenticate_Test_Admin_Identity() { IIdentityProvider serviceProvider = new CloudIdentityProvider(_testAdminIdentity); var userAccess = serviceProvider.Authenticate(); Assert.IsNotNull(userAccess); }
public void TestValidateToken() { IIdentityProvider provider = new CloudIdentityProvider(Bootstrapper.Settings.TestIdentity); UserAccess userAccess = provider.Authenticate(); Assert.IsNotNull(userAccess); Assert.IsNotNull(userAccess.Token); Assert.IsNotNull(userAccess.Token.Id); try { UserAccess validated = provider.ValidateToken(userAccess.Token.Id); Assert.IsNotNull(validated); Assert.IsNotNull(validated.Token); Assert.AreEqual(userAccess.Token.Id, validated.Token.Id); Assert.IsNotNull(validated.User); Assert.AreEqual(userAccess.User.Id, validated.User.Id); Assert.AreEqual(userAccess.User.Name, validated.User.Name); Assert.AreEqual(userAccess.User.DefaultRegion, validated.User.DefaultRegion); } catch (UserNotAuthorizedException ex) { if (ex.Response.StatusCode != HttpStatusCode.Forbidden) throw; Assert.Inconclusive("The service does not allow this user to access the Validate Token API."); } }
public static void Main(string[] args) { if (args.Length < 2 || args.Length > 3) { Console.WriteLine("Usage: {0} username api_key [region (US|UK)]", Environment.CommandLine); Environment.Exit(1); } RackspaceImpersonationIdentity auth = new RackspaceImpersonationIdentity(); auth.Username = args[0]; auth.APIKey = args[1]; if (args.Length == 3) { if (args[2] != "UK" && args[2] != "US") { Console.WriteLine("region must be either US or UK", Environment.CommandLine); Environment.Exit(1); } switch (args[2]) { case "UK": { auth.CloudInstance = CloudInstance.UK; }; break; case "US": { auth.CloudInstance = CloudInstance.Default; }; break; } } else { auth.CloudInstance = CloudInstance.Default; } try { IIdentityProvider identityProvider = new CloudIdentityProvider(); var userAccess = identityProvider.Authenticate(auth); } catch (ResponseException ex2) { Console.WriteLine("Authentication failed with the following message: {0}", ex2.Message); Environment.Exit(1); } var cloudServers = new CloudServersProvider(auth); var servers = cloudServers.ListServers(); foreach (Server serv in servers) { var date = System.DateTime.Now; var success = serv.CreateSnapshot(serv.Name + "_" + date.Year + "-" + date.Month + "-" + date.Day); if (success) { Console.WriteLine("Image for server {0} has been created successfully.", serv.Name); } else { Console.WriteLine("Image for server {0} could not be created.", serv.Name); } } }
private CloudIdentity CreateIdentity(string username, string apikey) { var result = new CloudIdentity() { Username = username, APIKey = apikey }; var provider = new CloudIdentityProvider(); var ua = provider.Authenticate(result); return result; }
public void Should_Not_Hit_Cache_When_Authenticating_The_First_Time() { var cacheMock = new Mock<ICache<UserAccess>>(); var restServiceMock = new Mock<IRestService>(); restServiceMock.Setup(m => m.Execute<AuthenticationResponse>(It.IsAny<string>(), It.IsAny<HttpMethod>(), It.IsAny<string>(), It.IsAny<Dictionary<string, string>>(), It.IsAny<Dictionary<string, string>>(), It.IsAny<RequestSettings>())).Returns(new Response<AuthenticationResponse>(200, "OK", new AuthenticationResponse(), new List<HttpHeader>(), null)); restServiceMock.Setup(m => m.Execute<AuthenticationResponse>(It.IsAny<Uri>(), It.IsAny<HttpMethod>(), It.IsAny<string>(), It.IsAny<Dictionary<string, string>>(), It.IsAny<Dictionary<string, string>>(), It.IsAny<RequestSettings>())).Returns(new Response<AuthenticationResponse>(200, "OK", new AuthenticationResponse(), new List<HttpHeader>(), null)); var identityProvider = new CloudIdentityProvider(restServiceMock.Object, cacheMock.Object); identityProvider.Authenticate(new RackspaceCloudIdentity()); cacheMock.Verify(m => m.Get(It.IsAny<string>(), It.IsAny<Func<UserAccess>>(), true), Times.Once()); }
public void Should_Always_Request_Fresh_Data_From_Cache_When_Authenticating() { var cacheMock = new Mock<ICache<UserAccess>>(); var restServiceMock = new Mock<IRestService>(); restServiceMock.Setup(m => m.Execute<AuthenticationResponse>(It.IsAny<string>(), It.IsAny<HttpMethod>(), It.IsAny<string>(), It.IsAny<Dictionary<string, string>>(), It.IsAny<Dictionary<string, string>>(), It.IsAny<RequestSettings>())).Returns(new Response<AuthenticationResponse>(200, "OK", new AuthenticationResponse(), new List<HttpHeader>(), null)); restServiceMock.Setup(m => m.Execute<AuthenticationResponse>(It.IsAny<Uri>(), It.IsAny<HttpMethod>(), It.IsAny<string>(), It.IsAny<Dictionary<string, string>>(), It.IsAny<Dictionary<string, string>>(), It.IsAny<RequestSettings>())).Returns(new Response<AuthenticationResponse>(200, "OK", new AuthenticationResponse(), new List<HttpHeader>(), null)); var identityProvider = new CloudIdentityProvider(restServiceMock.Object, cacheMock.Object); for (int i = 0; i < 100; i++) { identityProvider.Authenticate(new RackspaceCloudIdentity()); } cacheMock.Verify(m => m.Get(It.IsAny<string>(), It.IsAny<Func<UserAccess>>(), true), Times.Exactly(100)); }
public async Task Run(string username, string apiKey, string region) { // Configure authentication var identity = new CloudIdentity { Username = username, APIKey = apiKey }; var identityService = new CloudIdentityProvider(identity); var result = identityService.Authenticate(); var serverService = new CloudServersProvider(identity, region, null, null); var rackConnectService = new RackConnectService(identityService, region); // Create a cloud server on your hybrid network Console.WriteLine($"Looking up your RackConnect network in {region}..."); var networks = await rackConnectService.ListNetworksAsync(); var network = networks.FirstOrDefault(); if (network == null) throw new Exception($"You do not have a Hybrid Cloud / RackConnect network configured in the {region} which is required to run this sample."); Console.WriteLine("Creating sample cloud server... "); // Ubuntu 14.04 LTS (Trusty Tahr) (PVHVM) const string ubuntuImageId = "09de0a66-3156-48b4-90a5-1cf25a905207"; // 512MB Standard Instance const string standardFlavorId = "2"; var requestedServer = serverService.CreateServer("sample", ubuntuImageId, standardFlavorId, networks: new string[] {network.Id}); serverService.WaitForServerActive(requestedServer.Id); Console.WriteLine("Allocating a public IP address..."); var ip = await rackConnectService.CreatePublicIPAsync( new PublicIPCreateDefinition {ShouldRetain = true}); await ip.WaitUntilActiveAsync(); Console.WriteLine($"Acquired {ip.PublicIPv4Address}!"); Console.WriteLine("Assigning the public IP to the sample cloud server..."); await ip.AssignAsync(requestedServer.Id); await ip.WaitUntilActiveAsync(); Console.WriteLine("Deleting sample cloud server..."); serverService.DeleteServer(requestedServer.Id); Console.WriteLine("Deallocating the public IP address..."); await ip.DeleteAsync(); }
public void TestAuthenticate() { IIdentityProvider provider = new CloudIdentityProvider(Bootstrapper.Settings.TestIdentity); UserAccess userAccess = provider.Authenticate(); Assert.IsNotNull(userAccess); Assert.IsNotNull(userAccess.Token); Assert.IsNotNull(userAccess.Token.Id); Assert.IsNotNull(userAccess.Token.Expires); Assert.IsFalse(userAccess.Token.IsExpired); Assert.IsNotNull(userAccess.User); Assert.IsNotNull(userAccess.User.Id); Assert.IsNotNull(userAccess.User.Name); Assert.IsNotNull(userAccess.ServiceCatalog); Console.WriteLine(JsonConvert.SerializeObject(userAccess, Formatting.Indented)); }
public void Should_Throw_Error_When_Authenticating_With_Invalid_Password() { var identity = new RackspaceCloudIdentity() { Username = _testIdentity.Username, Password = "******" }; IIdentityProvider serviceProvider = new CloudIdentityProvider(identity); try { var userAccess = serviceProvider.Authenticate(); throw new Exception("This code path is invalid, exception was expected."); } catch (net.openstack.Core.Exceptions.Response.ResponseException) { Assert.IsTrue(true); } }
static bool Login() { auth = new RackspaceCloudIdentity(); auth.Username = Username; auth.Password = Password; auth.APIKey = APIKey; auth.CloudInstance = AccountRegion == "LON" ? CloudInstance.UK : CloudInstance.Default; try { CloudIdentityProvider identityProvider = new CloudIdentityProvider(); var userAccess = identityProvider.Authenticate(auth); } catch (Exception ex) { PrintException(ex); return false; } return true; }
//Method to Authenticate the credentials and obtain token public void Authenticate() { try { //Creating an instance of CloudIdentityProvider providing the CloudIdentity object and urls in the constructor provider = new CloudIdentityProvider(identity, "https://identity.api.rackspacecloud.com/v1.0", "https://lon.identity.api.rackspacecloud.com/v1.0"); //Calling the authenticate method which returns an UserAccess object containing token and user details UserAccess access = provider.Authenticate(identity); token = access.Token; userdetails = access.User; //Set the TokenId property TokenId = token.Id; //Verify with other programmers to make this method void cloudFiles = new CloudFilesProvider(identity); //return token.Id; } catch (UserAuthenticationException ex) { Console.WriteLine(ex.Message); throw ex; } catch (UserAuthorizationException ex) { Console.WriteLine(ex.Message); throw ex; } catch (UserNotAuthorizedException ex) { Console.WriteLine(ex.Message); throw ex; } catch (Exception ex) { Console.WriteLine(ex.Message); throw ex; } }
public void Should_Authenticate_NewUser() { Assert.IsNotNull(_testUser); IIdentityProvider provider = new CloudIdentityProvider(); var userAccess = provider.Authenticate(new RackspaceCloudIdentity {Username = _testUser.Username, Password = _newTestUserPassword}); Assert.IsNotNull(userAccess); }
public static void Main(string[] args) { Boolean containerExists = false; if (args.Length < 4 || args.Length > 5) { Console.WriteLine("Usage: {0} username api_key target_container path_to_file [region (US|UK)]", Environment.CommandLine); Environment.Exit(1); } RackspaceCloudIdentity auth = new RackspaceCloudIdentity(); IEnumerable<Container> containerList = null; auth.Username = args[0]; auth.APIKey = args[1]; targetContainer = args[2]; filePath = args[3]; if (args.Length == 5) { if (args[4] != "UK" && args[4] != "US") { Console.WriteLine("region must be either US or UK", Environment.CommandLine); Environment.Exit(1); } switch (args[4]) { case "UK": {auth.CloudInstance = CloudInstance.UK;};break; case "US": { auth.CloudInstance = CloudInstance.Default;}; break; } } try { IIdentityProvider identityProvider = new CloudIdentityProvider(); var userAccess = identityProvider.Authenticate(auth); } catch (ResponseException ex2) { Console.WriteLine("Authentication failed with the following message: {0}",ex2.Message); Environment.Exit(1); } try { var cloudFilesProvider = new CloudFilesProvider(auth); containerList = cloudFilesProvider.ListContainers(); foreach (Container container in containerList) { if (container.Name == targetContainer) { containerExists = true; break; } } if (!containerExists) { Console.WriteLine("Container \"{0}\" does not exist on the provided CloudFiles account.", targetContainer); Environment.Exit(1); } if (!File.Exists(filePath)) { Console.WriteLine("The file specified ({0}) does not exist", filePath); Environment.Exit(1); } cloudFilesProvider.CreateObjectFromFile(targetContainer, @filePath, Path.GetFileName(filePath)); } catch (Exception ex2) { Console.WriteLine(ex2.Message); Environment.Exit(1); } Console.WriteLine("*SUCCESS* File: \"{0}\" uploaded to \"{1}\"", filePath, targetContainer); }
public void TestListEndpoints() { IIdentityProvider provider = new CloudIdentityProvider(Bootstrapper.Settings.TestIdentity); UserAccess userAccess = provider.Authenticate(); Assert.IsNotNull(userAccess); Assert.IsNotNull(userAccess.Token); Assert.IsNotNull(userAccess.Token.Id); try { IEnumerable<ExtendedEndpoint> endpoints = provider.ListEndpoints(userAccess.Token.Id); Console.WriteLine(JsonConvert.SerializeObject(userAccess, Formatting.Indented)); } catch (UserNotAuthorizedException ex) { if (ex.Response.StatusCode != HttpStatusCode.Forbidden) throw; Assert.Inconclusive("The service does not allow this user to access the List Endpoints API."); } }