示例#1
0
        /// <summary>
        /// Get information about the specified DB System.
        /// </summary>
        /// <param name="request">The request object containing the details to send. Required.</param>
        /// <param name="retryConfiguration">The retry configuration that will be used by to send this request. Optional.</param>
        /// <param name="cancellationToken">The cancellation token to cancel this operation. Optional.</param>
        /// <returns>A response object containing details about the completed operation</returns>
        /// <example>Click <a href="https://docs.cloud.oracle.com/en-us/iaas/tools/dot-net-examples/latest/mysql/GetDbSystem.cs.html">here</a> to see an example of how to use GetDbSystem API.</example>
        public async Task <GetDbSystemResponse> GetDbSystem(GetDbSystemRequest request, RetryConfiguration retryConfiguration = null, CancellationToken cancellationToken = default)
        {
            logger.Trace("Called getDbSystem");
            Uri                uri            = new Uri(this.restClient.GetEndpoint(), System.IO.Path.Combine(basePathWithoutHost, "/dbSystems/{dbSystemId}".Trim('/')));
            HttpMethod         method         = new HttpMethod("GET");
            HttpRequestMessage requestMessage = Converter.ToHttpRequestMessage(uri, method, request);

            requestMessage.Headers.Add("Accept", "application/json");
            GenericRetrier      retryingClient = Retrier.GetPreferredRetrier(retryConfiguration, this.retryConfiguration);
            HttpResponseMessage responseMessage;

            try
            {
                if (retryingClient != null)
                {
                    responseMessage = await retryingClient.MakeRetryingCall(this.restClient.HttpSend, requestMessage, cancellationToken).ConfigureAwait(false);
                }
                else
                {
                    responseMessage = await this.restClient.HttpSend(requestMessage).ConfigureAwait(false);
                }
                this.restClient.CheckHttpResponseMessage(requestMessage, responseMessage);

                return(Converter.FromHttpResponseMessage <GetDbSystemResponse>(responseMessage));
            }
            catch (Exception e)
            {
                logger.Error($"GetDbSystem failed with error: {e.Message}");
                throw;
            }
        }
        private static async Task terminateDbSystem(DatabaseClient databaseClient, string dbSystemId)
        {
            try
            {
                logger.Info("Terminating the Database...");

                TerminateDbSystemRequest terminateDbSystemRequest = new TerminateDbSystemRequest
                {
                    DbSystemId = dbSystemId
                };
                await databaseClient.TerminateDbSystem(terminateDbSystemRequest);

                GetDbSystemRequest getDbSystemRequest = new GetDbSystemRequest
                {
                    DbSystemId = dbSystemId
                };
                WaiterConfiguration waiterConfiguration = new WaiterConfiguration
                {
                    MaxAttempts           = 20,
                    GetNextDelayInSeconds = DelayStrategy.GetExponentialDelayInSeconds
                };
                databaseClient.Waiters.ForDbSystem(getDbSystemRequest, waiterConfiguration, DbSystem.LifecycleStateEnum.Terminated).Execute();

                logger.Info("Database terminated");
            }
            catch (Exception e)
            {
                logger.Error($"failed to terminate DbSystem: {e}");
            }
        }
示例#3
0
        /// <summary>
        /// Creates a waiter using the provided configuration.
        /// </summary>
        /// <param name="request">Request to send.</param>
        /// <param name="config">Wait Configuration</param>
        /// <param name="targetStates">Desired resource states. If multiple states are provided then the waiter will return once the resource reaches any of the provided states</param>
        /// <returns>a new Oci.common.Waiter instance</returns>
        public Waiter <GetDbSystemRequest, GetDbSystemResponse> ForDbSystem(GetDbSystemRequest request, WaiterConfiguration config, params DbSystem.LifecycleStateEnum[] targetStates)
        {
            var agent = new WaiterAgent <GetDbSystemRequest, GetDbSystemResponse>(
                request,
                request => client.GetDbSystem(request),
                response => targetStates.Contains(response.DbSystem.LifecycleState.Value),
                targetStates.Contains(DbSystem.LifecycleStateEnum.Deleted)
                );

            return(new Waiter <GetDbSystemRequest, GetDbSystemResponse>(config, agent));
        }
示例#4
0
        /// <summary>
        /// Gets information about the specified DB system.
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        public async Task <GetDbSystemResponse> GetDbSystem(GetDbSystemRequest request)
        {
            var uri = new Uri($"{GetEndPoint(DatabaseServices.DbSystems, this.Region)}/{request.DbSystemId}");

            using (var webResponse = await this.RestClientAsync.Get(uri))
                using (var stream = webResponse.GetResponseStream())
                    using (var reader = new StreamReader(stream))
                    {
                        var response = await reader.ReadToEndAsync();

                        return(new GetDbSystemResponse()
                        {
                            DbSystem = this.JsonSerializer.Deserialize <DbSystemDetails>(response),
                            OpcRequestId = webResponse.Headers.Get("opc-request-id"),
                            ETag = webResponse.Headers.Get("ETag")
                        });
                    }
        }
示例#5
0
        private void HandleOutput(GetDbSystemRequest request)
        {
            var waiterConfig = new WaiterConfiguration
            {
                MaxAttempts           = MaxWaitAttempts,
                GetNextDelayInSeconds = (_) => WaitIntervalSeconds
            };

            switch (ParameterSetName)
            {
            case LifecycleStateParamSet:
                response = client.Waiters.ForDbSystem(request, waiterConfig, WaitForLifecycleState).Execute();
                break;

            case Default:
                response = client.GetDbSystem(request).GetAwaiter().GetResult();
                break;
            }
            WriteOutput(response, response.DbSystem);
        }
示例#6
0
        protected override void ProcessRecord()
        {
            base.ProcessRecord();
            GetDbSystemRequest request;

            try
            {
                request = new GetDbSystemRequest
                {
                    DbSystemId = DbSystemId
                };

                HandleOutput(request);
                FinishProcessing(response);
            }
            catch (Exception ex)
            {
                TerminatingErrorDuringExecution(ex);
            }
        }
示例#7
0
 /// <summary>
 /// Creates a waiter using default wait configuration.
 /// </summary>
 /// <param name="request">Request to send.</param>
 /// <param name="targetStates">Desired resource states. If multiple states are provided then the waiter will return once the resource reaches any of the provided states</param>
 /// <returns>a new Oci.common.Waiter instance</returns>
 public Waiter <GetDbSystemRequest, GetDbSystemResponse> ForDbSystem(GetDbSystemRequest request, params DbSystem.LifecycleStateEnum[] targetStates)
 {
     return(this.ForDbSystem(request, WaiterConfiguration.DefaultWaiterConfiguration, targetStates));
 }
        static void Main(string[] args)
        {
            Console.WriteLine("+----------------------------------------+");
            Console.WriteLine("|                                        |");
            Console.WriteLine("|         OCISDK SessionExample          |");
            Console.WriteLine("|                                        |");
            Console.WriteLine("+----------------------------------------+");

            string configPath = ".oci/config";

            System.OperatingSystem os = System.Environment.OSVersion;
            // windows
            if (os.Platform == PlatformID.Win32NT)
            {
                string rootPath = Directory.GetDirectoryRoot(Directory.GetCurrentDirectory());
                configPath = $"{rootPath}/{configPath}";
                if (!Directory.Exists($"{rootPath}/.oci"))
                {
                    Directory.CreateDirectory($"{rootPath}/.oci");
                }
            }
            else
            {
                configPath = $"/home/user/{configPath}";
            }

            string     profile;
            ConfigFile configReader;

            if (File.Exists(configPath))
            {
                Console.Write("Connection ProfileName(Empty Input is DEFAULT): ");
                profile = Console.ReadLine();
                if (string.IsNullOrEmpty(profile))
                {
                    profile = "DEFAULT";
                }

                // load connection file
                configReader = ConfigFileReader.Parse(configPath, profile);
            }
            else
            {
                profile = "DEFAULT";

                // create connection file
                Console.WriteLine("Create connection settings to Oracle Cloud Infrastructure");

                Console.Write("TenancyId (Required): ");
                string tenancyId = OCIDInput();

                Console.Write("UserId (Required): ");
                string userId = OCIDInput();

                Console.Write("Fingerprint (Required): ");
                string fingerprint = KeyInput();

                Console.Write("PrivateKeyPath (Required): ");
                string privateKeyPath = KeyInput();

                Console.Write("PrivateKeyPassphrase: ");
                string privateKeyPassphrase = InputPassword();

                string testFileContentsMyProfile = $"[{profile}]\n" +
                                                   $"tenancy={tenancyId}\n" +
                                                   $"user={userId}\n" +
                                                   $"fingerprint={fingerprint}\n" +
                                                   $"key_file={privateKeyPath}\n" +
                                                   $"pass_phrase={privateKeyPassphrase}\n";

                File.WriteAllText(configPath, testFileContentsMyProfile);

                configReader = ConfigFileReader.Parse(configPath, profile);
            }

            // ClientConfig settings
            var         configSt = new ClientConfigStream();
            IOciSession session;

            using (var st = File.OpenText(configReader.Get("key_file")))
            {
                configSt = new ClientConfigStream
                {
                    TenancyId            = configReader.Get("tenancy"),
                    UserId               = configReader.Get("user"),
                    Fingerprint          = configReader.Get("fingerprint"),
                    PrivateKey           = st,
                    PrivateKeyPassphrase = configReader.Get("pass_phrase"),
                    AccountId            = configReader.Get("accountId"),
                    IdentityDomain       = configReader.Get("domain"),
                    UserName             = configReader.Get("user"),
                    Password             = configReader.Get("password"),
                    HomeRegion           = configReader.Get("home_region")
                };

                session = new OciSession(configSt);
            }

            var comClient = session.GetCommercialClient();
            var listPurchaseEntitlementsRequest = new ListPurchaseEntitlementsRequest
            {
                CompartmentId = configSt.TenancyId
            };
            var purchase = comClient.ListPurchaseEntitlements(listPurchaseEntitlementsRequest);

            var getServiceEntitlementRegistrationsRequest = new ListServiceEntitlementRegistrationsRequest()
            {
                CompartmentId = configSt.TenancyId
            };
            var services = comClient.ListServiceEntitlementRegistrations(getServiceEntitlementRegistrationsRequest);

            var costClient = session.GetUsageCostsClient();
            var getSubscriptionInfoRequest = new GetSubscriptionInfoRequest
            {
                TenancyId = configSt.TenancyId
            };
            var subsc = costClient.GetSubscriptionInfo(getSubscriptionInfoRequest);

            // get Client
            var identityClient = session.GetIdentityClient();

            var getTenancyRequest = new GetTenancyRequest()
            {
                TenancyId = configSt.TenancyId
            };
            var getTenacy = identityClient.GetTenancy(getTenancyRequest);

            Console.WriteLine($"tenantName: {getTenacy.Tenancy.Name}");

            // get compute
            var computeClient = session.GetComputeClient();

            IDictionary <string, IDictionary <string, string> > tags = new Dictionary <string, IDictionary <string, string> >();

            tags.Add("CostTracking", new Dictionary <string, string> {
                { "cost-trakcerA", "aaaa" }
            });

            var dbClient = session.GetDatabaseClient();
            GetDbSystemRequest getDbSystemRequest = new GetDbSystemRequest()
            {
                DbSystemId = "ocid1.dbsystem.oc1.iad.abuwcljrbukbjzlameegvsn3u7qb3qcqvtcdvl74jxfth7xjsya7cxkdpibq"
            };
            var dbSystem = dbClient.GetDbSystem(getDbSystemRequest);

            UpdateDbSystemRequest updateDbSystemRequest = new UpdateDbSystemRequest()
            {
                DbSystemId            = "ocid1.dbsystem.oc1.iad.abuwcljrbukbjzlameegvsn3u7qb3qcqvtcdvl74jxfth7xjsya7cxkdpibq",
                UpdateDbSystemDetails = new OCISDK.Core.Database.Model.UpdateDbSystemDetails()
                {
                    DefinedTags = tags
                }
            };

            dbClient.UpdateDbSystem(updateDbSystemRequest);

            var listCompartmentRequest = new ListCompartmentRequest()
            {
                CompartmentId          = getTenacy.Tenancy.Id,
                CompartmentIdInSubtree = true
            };
            var cmparts = identityClient.ListCompartment(listCompartmentRequest);

            foreach (var com in cmparts.Items)
            {
                Console.WriteLine($"compartmentName: {com.Name}");

                var listInstanceRequest = new ListInstancesRequest()
                {
                    CompartmentId = com.Id,
                    Limit         = 10,
                    SortOrder     = SortOrder.ASC
                };
                var instances = computeClient.ListInstances(listInstanceRequest);
                foreach (var ins in instances.Items)
                {
                    Console.WriteLine($"rootCompartmentInstanceName: {ins.DisplayName}");


                    var workReqestClient        = session.GetWorkRequestClient();
                    var listWorkRequestsRequest = new OCISDK.Core.Core.Request.WorkRequest.ListWorkRequestsRequest()
                    {
                        CompartmentId = ins.CompartmentId,
                        ResourceId    = ins.Id
                    };
                    var workreqs = workReqestClient.ListWorkRequests(listWorkRequestsRequest);
                    foreach (var wq in workreqs.Items)
                    {
                        Console.WriteLine($"\tWorkRequest: {wq.OperationType}, state:{wq.Status}");

                        var getWorkRequestRequest = new OCISDK.Core.Core.Request.WorkRequest.GetWorkRequestRequest()
                        {
                            WorkRequestId = wq.Id
                        };
                        var gw = workReqestClient.GetWorkRequest(getWorkRequestRequest);
                        Console.WriteLine($"\taccepted:{gw.WorkRequest.TimeAccepted}, finished:{gw.WorkRequest.TimeFinished}");

                        var listWorkRequestErrorsRequest = new OCISDK.Core.Core.Request.WorkRequest.ListWorkRequestErrorsRequest()
                        {
                            WorkRequestId = wq.Id,
                            Limit         = 100,
                            SortOrder     = SortOrder.ASC
                        };
                        var wqErrors = workReqestClient.ListWorkRequestErrors(listWorkRequestErrorsRequest);
                        foreach (var error in wqErrors.Items)
                        {
                            Console.WriteLine($"\tErrorCode: {error.Code}, ErrorMessage:{error.Message}, ErrorTimeStamp:{error.Timestamp}");
                        }

                        var listWorkRequestLogsRequest = new OCISDK.Core.Core.Request.WorkRequest.ListWorkRequestLogsRequest()
                        {
                            WorkRequestId = wq.Id,
                            Limit         = 100,
                            SortOrder     = SortOrder.ASC
                        };
                        var wqLogs = workReqestClient.ListWorkRequestLogs(listWorkRequestLogsRequest);
                        foreach (var log in wqLogs.Items)
                        {
                            Console.WriteLine($"\tLogMessage:{log.Message}, LogTimeStamp:{log.Timestamp}");
                        }
                    }
                }
            }

            Console.WriteLine("Exit with key press...");
            Console.ReadLine();
        }
        static async Task MainDatabase(string[] args)
        {
            string compartmentId = Environment.GetEnvironmentVariable("OCI_COMPARTMENT_ID");
            string adminPassword = Environment.GetEnvironmentVariable("PASSWORD");

            logger.Info("Starting example");
            // Accepts profile name and creates a auth provider based on config file
            var provider = new ConfigFileAuthenticationDetailsProvider(OciConfigProfileName);

            var identityClient       = new IdentityClient(provider);
            var virtualNetworkClient = new VirtualNetworkClient(provider);
            var databaseClient       = new DatabaseClient(provider);
            var networkCidrBlock     = "10.0.1.0/24";

            Vcn    vcn        = null;
            Subnet subnet     = null;
            string dbSystemId = null;

            AvailabilityDomain availablityDomain = await getAvailabilityDomains(identityClient, compartmentId);

            logger.Info($"availability domain is {availablityDomain.Name}");

            try
            {
                vcn = await createVcn(virtualNetworkClient, compartmentId, networkCidrBlock);

                subnet = await createSubnet(virtualNetworkClient, compartmentId, availablityDomain, networkCidrBlock, vcn);

                logger.Info("Launching Database....");

                LaunchDbSystemDetails launchDbSystemDetails = new LaunchDbSystemDetails
                {
                    AvailabilityDomain = availablityDomain.Name,
                    CompartmentId      = compartmentId,
                    CpuCoreCount       = 4,
                    Shape         = "BM.DenseIO2.52",
                    SshPublicKeys = new List <string> {
                        "ssh-rsa AAAAB3NzaC1yc2EAAAABIwAAAQEAyyA8wePstPC69PeuHFtOwyTecByonsHFAjHbVnZ+h0dpomvLZxUtbknNj3+c7MPYKqKBOx9gUKV/diR/mIDqsb405MlrI1kmNR9zbFGYAAwIH/Gxt0Lv5ffwaqsz7cECHBbMojQGEz3IH3twEvDfF6cu5p00QfP0MSmEi/eB+W+h30NGdqLJCziLDlp409jAfXbQm/4Yx7apLvEmkaYSrb5f/pfvYv1FEV1tS8/J7DgdHUAWo6gyGUUSZJgsyHcuJT7v9Tf0xwiFWOWL9WsWXa9fCKqTeYnYJhHlqfinZRnT/+jkz0OZ7YmXo6j4Hyms3RCOqenIX1W6gnIn+eQIkw== This is the key's comment"
                    },
                    SubnetId        = subnet.Id,
                    DatabaseEdition = LaunchDbSystemDetails.DatabaseEditionEnum.EnterpriseEdition,
                    DisplayName     = "OCI DotNet SDK database",
                    Hostname        = "oci-dotnetsdk-host",
                    Domain          = "testdomain",
                    DbHome          = new CreateDbHomeDetails
                    {
                        DbVersion   = "12.1.0.2",
                        DisplayName = "Example DB Home",
                        Database    = new CreateDatabaseDetails
                        {
                            DbName        = "dotnetdb",
                            AdminPassword = adminPassword
                        }
                    }
                };

                LaunchDbSystemRequest launchDbSystemRequest = new LaunchDbSystemRequest
                {
                    LaunchDbSystemDetails = launchDbSystemDetails
                };
                LaunchDbSystemResponse launchDbSystemResponse = await databaseClient.LaunchDbSystem(launchDbSystemRequest);

                logger.Info($"Database ID: {launchDbSystemResponse.DbSystem.Id} and Database display name: {launchDbSystemResponse.DbSystem.DisplayName}");
                logger.Info("Waiting for Database to come to available state....");

                GetDbSystemRequest getDbSystemRequest = new GetDbSystemRequest
                {
                    DbSystemId = launchDbSystemResponse.DbSystem.Id
                };
                WaiterConfiguration waiterConfiguration = new WaiterConfiguration
                {
                    MaxAttempts           = 20,
                    GetNextDelayInSeconds = DelayStrategy.GetExponentialDelayInSeconds
                };
                GetDbSystemResponse getDbSystemResponse = databaseClient.Waiters.ForDbSystem(
                    getDbSystemRequest, waiterConfiguration, DbSystem.LifecycleStateEnum.Available).Execute();

                logger.Info("Database is available");
                logger.Info($"Database ID: {getDbSystemResponse.DbSystem.Id} and Database display name: {getDbSystemResponse.DbSystem.DisplayName}");
                dbSystemId = getDbSystemResponse.DbSystem.Id;
            }
            catch (Exception e)
            {
                logger.Error($"failed to launch DbSystem: {e}");
            }
            finally
            {
                if (dbSystemId != null)
                {
                    await terminateDbSystem(databaseClient, dbSystemId);
                }

                if (subnet != null)
                {
                    await deleteSubnet(virtualNetworkClient, subnet);
                }

                if (vcn != null)
                {
                    await deleteVcn(virtualNetworkClient, vcn);
                }

                identityClient.Dispose();
                virtualNetworkClient.Dispose();
                databaseClient.Dispose();

                logger.Info("End example");
            }
        }