C# Session.login_with_password方法代码示例

        public static void Main(string[] args)
        {
            if (args.Length < 3)
            {
                System.Console.WriteLine("Required arguments: host-ip username password\n");
                return;
            }

            // Host information necessary to get started
            string hostname = args[0];
            int port = 80; // default
            string username = args[1];
            string password = args[2];

            // Establish a session
            Session session = new Session(hostname, port);

            // Authenticate with username and password. The third parameter tells the server which API version we support.
            session.login_with_password(username, password, API_Version.API_1_3);

            List<XenRef<VM>> vmRefs = VM.get_all(session);
            foreach (XenRef<VM> vmRef in vmRefs)
            {
                VM vm = VM.get_record(session, vmRef);
                System.Console.WriteLine("Name: {0}\nvCPUs: {1}\nDescription: {2}\n-", vm.name_label, vm.VCPUs_at_startup, vm.name_description);
            }
        }

        public static void Main(string[] args)
        {
            if (args.Length < 3)
            {
                System.Console.WriteLine("Required arguments: host-ip username password\n");
                return;
            }

            // Host information necessary to get started
            string hostname = args[0];
            int port = 443; // default
            string username = args[1];
            string password = args[2];

            // Establish a session
            ServicePointManager.ServerCertificateValidationCallback = delegate { return true; };  // Trust all certificates: DO NOT USE IN PRODUCTION CODE!
            ServicePointManager.SecurityProtocol = SecurityProtocolType.Tls | SecurityProtocolType.Tls11 | SecurityProtocolType.Tls12;
            Session session = new Session(hostname, port);

            // Authenticate with username and password. The third parameter tells the server which API version we support.
            session.login_with_password(username, password, API_Version.API_1_3);

            // Choose a VM at random which is not a template or control domain and which is currently switched off.
            XenRef<VM> chosenRef = null;
            foreach (KeyValuePair<XenRef<VM>, VM> kvp in VM.get_all_records(session))
            {
                VM vm = kvp.Value;
                if (!vm.is_a_template && !vm.is_control_domain && vm.power_state == vm_power_state.Halted)
                {
                    chosenRef = kvp.Key;
                    break;
                }
            }

            string cloneVM = null;
            if (chosenRef != null)
            {
                // clone the vm
                VM chosenVM = VM.get_record(session, chosenRef);
                System.Console.WriteLine("Cloning VM '{0}'...", chosenVM.name_label);
                cloneVM = VM.clone(session, chosenRef, string.Format("Cloned VM (from '{0}')", chosenVM.name_label));
                System.Console.WriteLine("Cloned VM; new VM is {0}", cloneVM);

                // set its description
                VM.set_name_description(session, cloneVM, "Another cloned VM");
                System.Console.WriteLine("VM name: {0} Description: {1} Power State: {2}",
                                            VM.get_name_label(session, cloneVM),
                                            VM.get_name_description(session, cloneVM),
                                            VM.get_power_state(session, cloneVM));

                // start the clone in a paused state
                System.Console.WriteLine("Starting VM paused...");
                VM.start(session, cloneVM, true, true);
                System.Console.WriteLine("VM Power State: {0}", VM.get_power_state(session, cloneVM));

                // unpause it
                System.Console.WriteLine("Unpausing VM...");
                VM.unpause(session, cloneVM);
                System.Console.WriteLine("VM Power State: {0}", VM.get_power_state(session, cloneVM));

                // now suspend it
                System.Console.WriteLine("Suspending VM...");
                VM.suspend(session, cloneVM);
                System.Console.WriteLine("VM Power State: {0}", VM.get_power_state(session, cloneVM));

                // and then resume
                System.Console.WriteLine("Resuming VM...");
                VM.resume(session, cloneVM, false, true);
                System.Console.WriteLine("VM Power State: {0}", VM.get_power_state(session, cloneVM));

                // and then shutdown
                System.Console.WriteLine("Forcing shutdown VM...");
                VM.hard_shutdown(session, cloneVM);
                System.Console.WriteLine("VM Power State: {0}", VM.get_power_state(session, cloneVM));

                // now destroy it
                System.Console.WriteLine("Destroying VM...");
                VM.destroy(session, cloneVM);
                System.Console.WriteLine("VM destroyed.");
            }
            else
            {
                System.Console.WriteLine("No suitable VMs found (please install one)");
            }

            // watch it all before it vanishes
            System.Console.WriteLine("\nHit any key to exit\n");
            System.Console.ReadKey();
        }

        protected override void ProcessRecord()
        {
            if ((Url == null || Url.Length == 0) && (Server == null || Server.Length == 0))
            {
                ThrowTerminatingError(new ErrorRecord(
                      new Exception("You must provide a URL, Name or IP Address for the XenServer."),
                      "",
                      ErrorCategory.InvalidArgument,
                      null));
            }

            if (Creds == null &&
                (string.IsNullOrEmpty(UserName) || string.IsNullOrEmpty(Password)) &&
                 (OpaqueRef == null || OpaqueRef.Length == 0))
            {
                Creds = Host.UI.PromptForCredential("XenServer Credential Request",
                    "",
                    string.IsNullOrEmpty(UserName) ? "root" : UserName,
                    "");

                if (Creds == null)
                {
                    // Just bail out at this point, they've clicked cancel on the credentials pop up dialog
                    ThrowTerminatingError(new ErrorRecord(
                          new Exception("Credentials must be supplied when connecting to the XenServer."),
                          "",
                          ErrorCategory.InvalidArgument,
                          null));
                }
            }

            string connUser = "";
            string connPassword = "";

            if (OpaqueRef == null || OpaqueRef.Length == 0)
            {
                if (Creds == null)
                {
                    connUser = UserName;
                    connPassword = Password;

                    SecureString secPwd = new SecureString();
                    foreach (char ch in connPassword)
                        secPwd.AppendChar(ch);

                    Creds = new PSCredential(UserName, secPwd);
                }
                else
                {
                    connUser = Creds.UserName.StartsWith("\\")
                                   ? Creds.GetNetworkCredential().UserName
                                   : Creds.UserName;

                    IntPtr ptrPassword = Marshal.SecureStringToBSTR(Creds.Password);
                    connPassword = Marshal.PtrToStringBSTR(ptrPassword);
                    Marshal.FreeBSTR(ptrPassword);
                }
            }

            ServicePointManager.ServerCertificateValidationCallback = new RemoteCertificateValidationCallback(ValidateServerCertificate);
            ServicePointManager.SecurityProtocol = SecurityProtocolType.Tls | SecurityProtocolType.Tls11 | SecurityProtocolType.Tls12;

            if (Url == null || Url.Length == 0)
            {
                Url = new string[Server.Length];
                for (int i = 0; i < Server.Length; i++)
                    Url[i] = CommonCmdletFunctions.GetUrl(Server[i], Port);
            }

            if (OpaqueRef == null)
            {
                OpaqueRef = new string[Url.Length];
            }
            else
            {
                if (OpaqueRef.Length != Url.Length)
                    ThrowTerminatingError(new ErrorRecord(
                        new Exception("The number of opaque references provided should be the same as the number of xenservers."),
                        "",
                        ErrorCategory.InvalidArgument,
                        null));
            }

            Dictionary<string, Session> sessions = CommonCmdletFunctions.GetAllSessions(this);
            Dictionary<string, Session> newSessions = new Dictionary<string, Session>();

            for (int i = 0; i < Url.Length; i++)
            {
                Session session;
                if (string.IsNullOrEmpty(OpaqueRef[i]))
                {
                    session = new Session(Url[i]);
                    var apiVersionString = XenAPI.Helper.APIVersionString(session.APIVersion);
                    session.login_with_password(connUser, connPassword, apiVersionString, "XenServerPSModule/" + apiVersionString);
                }
                else
                {
                    session = new Session(Url[i], OpaqueRef[i]);
                }

//.........这里部分代码省略.........

        public void runUpload(System.Threading.CancellationToken serviceStop)
        {
            DateTime startTime = DateTime.UtcNow;
            string uploadToken = "";
            Session session = new Session(connection.Hostname, 80);
            session.APIVersion = API_Version.LATEST;

            try
            {
                session.login_with_password(connection.Username, connection.Password);
                connection.LoadCache(session);
                var pool = Helpers.GetPoolOfOne(connection);
                if (pool != null)
                {
                    try
                    {
                        string opaqueref = Secret.get_by_uuid(session, pool.HealthCheckSettings.UploadTokenSecretUuid);
                        uploadToken = Secret.get_value(session, opaqueref);
                    }
                    catch (Exception e)
                    {
                        log.Error("Exception getting the upload token from the xapi secret", e);
                        uploadToken = null;
                    }
                }

                if (string.IsNullOrEmpty(uploadToken))
                {
                    if (session != null)
                        session.logout();
                    session = null;
                    log.ErrorFormat("The upload token is not retrieved for {0}", connection.Hostname);
                    updateHealthCheckSettings(false, startTime);
                    server.task = null;
                    ServerListHelper.instance.UpdateServerInfo(server);
                    return;
                }

            }
            catch (Exception e)
            {
                if (session != null)
                    session.logout();
                session = null;
                log.Error(e, e);
                updateHealthCheckSettings(false, startTime);
                server.task = null;
                ServerListHelper.instance.UpdateServerInfo(server);
                return;
            }

            try
            {
                CancellationTokenSource cts = new CancellationTokenSource();
                Func<string> upload = delegate()
                {
                    try
                    {
                        return bundleUpload(connection, session, uploadToken, cts.Token);
                    }
                    catch (OperationCanceledException)
                    {
                        return "";
                    }
                };
                System.Threading.Tasks.Task<string> task = new System.Threading.Tasks.Task<string>(upload);
                task.Start();

                // Check if the task runs to completion before timeout.
                for (int i = 0; i < TIMEOUT; i += INTERVAL)
                {
                    // If the task finishes, set HealthCheckSettings accordingly.
                    if (task.IsCompleted || task.IsCanceled || task.IsFaulted)
                    {
                        if (task.Status == System.Threading.Tasks.TaskStatus.RanToCompletion)
                        {
                            string upload_uuid = task.Result;
                            if (!string.IsNullOrEmpty(upload_uuid))
                                updateHealthCheckSettings(true, startTime, upload_uuid);
                            else
                                updateHealthCheckSettings(false, startTime);
                        }
                        else
                            updateHealthCheckSettings(false, startTime);

                        server.task = null;
                        ServerListHelper.instance.UpdateServerInfo(server);
                        return;
                    }

                    // If the main thread (XenServerHealthCheckService) stops,
                    // set the cancel token to notify the working task to return.
                    if (serviceStop.IsCancellationRequested)
                    {
                        cts.Cancel();
                        updateHealthCheckSettings(false, startTime);
                        task.Wait();
                        server.task = null;
                        ServerListHelper.instance.UpdateServerInfo(server);
                        return;
//.........这里部分代码省略.........

        public void updateHealthCheckSettings(bool success, DateTime time, string uploadUuid = "")
        {
            Session session = new Session(connection.Hostname, 80);
            session.login_with_password(connection.Username, connection.Password);
            connection.LoadCache(session);

            // Round-trip format time
            DateTime rtime = DateTime.SpecifyKind(time, DateTimeKind.Utc);
            string stime = HealthCheckSettings.DateTimeToString(rtime);

            // record upload_uuid,
            // release the lock,
            // set the time of LAST_SUCCESSFUL_UPLOAD or LAST_FAILED_UPLOAD
            Dictionary<string, string> config = Pool.get_health_check_config(session, connection.Cache.Pools[0].opaque_ref);
            config[HealthCheckSettings.UPLOAD_LOCK] = "";
            if (success)
            {
                config[HealthCheckSettings.LAST_SUCCESSFUL_UPLOAD] = stime;
                config[HealthCheckSettings.UPLOAD_UUID] = uploadUuid;
                // reset the NEW_UPLOAD_REQUEST field, if the current successful upload was started after the request
                DateTime newUploadRequestTime;
                if (HealthCheckSettings.TryParseStringToDateTime(config[HealthCheckSettings.NEW_UPLOAD_REQUEST], out newUploadRequestTime))
                {
                    if (rtime > newUploadRequestTime)
                        config[HealthCheckSettings.NEW_UPLOAD_REQUEST] = "";
                }
            }
            else
                config[HealthCheckSettings.LAST_FAILED_UPLOAD] = stime;
            Pool.set_health_check_config(session, connection.Cache.Pools[0].opaque_ref, config);

            if (session != null)
                session.logout();
            session = null;
        }

        public void OnTimer(object sender, System.Timers.ElapsedEventArgs args)
        {
            log.Info("XenServer Health Check Service start to refresh uploading tasks");

            //We need to check if CIS can be accessed in current enviroment

            List<ServerInfo> servers = ServerListHelper.instance.GetServerList();
            foreach (ServerInfo server in servers)
            {
                if (server.task != null && (!server.task.IsCompleted || !server.task.IsCanceled || !server.task.IsFaulted))
                {
                    continue;
                }

                XenConnection connectionInfo = new XenConnection();
                connectionInfo.Hostname = server.HostName;
                connectionInfo.Username = server.UserName;
                connectionInfo.Password = server.Password;
                log.InfoFormat("Check server {0} with user {1}", connectionInfo.Hostname, connectionInfo.Username);
                Session session = new Session(server.HostName, 80);
                session.APIVersion = API_Version.LATEST;
                try
                {
                    session.login_with_password(server.UserName, server.Password);
                    connectionInfo.LoadCache(session);
                    if (RequestUploadTask.Request(connectionInfo, session) || RequestUploadTask.OnDemandRequest(connectionInfo, session))
                    {
                        // Create a task to collect server status report and upload to CIS server
                        log.InfoFormat("Start to upload server status report for XenServer {0}", connectionInfo.Hostname);

                        XenServerHealthCheckBundleUpload upload = new XenServerHealthCheckBundleUpload(connectionInfo);
                        Action uploadAction = delegate()
                        {
                            upload.runUpload(cts.Token);
                        };
                        System.Threading.Tasks.Task task = new System.Threading.Tasks.Task(uploadAction);
                        task.Start();

                        server.task = task;
                        ServerListHelper.instance.UpdateServerInfo(server);
                    }
                    session.logout();
                    session = null;
                }
                catch (Exception exn)
                {
                    if (session != null)
                        session.logout();
                    log.Error(exn, exn);
                }
            }
        }

        public void OnTimer(object sender, System.Timers.ElapsedEventArgs args)
        {
            log.Info("XenServer Health Check Service start to refresh uploading tasks");

            //We need to check if CIS can be accessed in current enviroment

            List<ServerInfo> servers = ServerListHelper.instance.GetServerList();
            foreach (ServerInfo server in servers)
            {
                if (server.task != null && (!server.task.IsCompleted || !server.task.IsCanceled || !server.task.IsFaulted))
                {
                    continue;
                }

                bool needReconnect = false;

                log.InfoFormat("Check server {0} with user {1}", server.HostName, server.UserName);

                Session session = new Session(server.HostName, 80);
                session.APIVersion = API_Version.LATEST;
                try
                {
                    session.login_with_password(server.UserName, server.Password, Helper.APIVersionString(API_Version.LATEST), Session.UserAgent);
                }
                catch (Exception exn)
                {
                    if (exn is Failure && ((Failure)exn).ErrorDescription[0] == Failure.HOST_IS_SLAVE)
                    {
                        string masterName = ((Failure)exn).ErrorDescription[1];
                        if (ServerListHelper.instance.UpdateServerCredential(server, masterName))
                        {
                            log.InfoFormat("Refresh credential to master {0} need refresh connection", masterName);
                            server.HostName = masterName;
                            needReconnect = true;
                        }
                        else
                        {
                            log.InfoFormat("Remove credential since it is the slave of master {0}", masterName);
                            if (session != null)
                                session.logout();
                            log.Error(exn, exn);
                            continue;
                        }
                    }
                    else
                    {
                        if (session != null)
                            session.logout();
                        log.Error(exn, exn);
                        continue;
                    }
                }

                try
                {
                    if (needReconnect)
                    {
                        if (session != null)
                            session.logout();
                        log.InfoFormat("Reconnect to master {0}", server.HostName);
                        session = new Session(server.HostName, 80);
                        session.APIVersion = API_Version.LATEST;
                        session.login_with_password(server.UserName, server.Password, Helper.APIVersionString(API_Version.LATEST), Session.UserAgent);
                    }
                    XenConnection connectionInfo = new XenConnection();
                    connectionInfo.Hostname = server.HostName;
                    connectionInfo.Username = server.UserName;
                    connectionInfo.Password = server.Password;
                    connectionInfo.LoadCache(session);
                    if (RequestUploadTask.Request(connectionInfo, session) || RequestUploadTask.OnDemandRequest(connectionInfo, session))
                    {
                        // Create a task to collect server status report and upload to CIS server
                        log.InfoFormat("Start to upload server status report for XenServer {0}", connectionInfo.Hostname);

                        XenServerHealthCheckBundleUpload upload = new XenServerHealthCheckBundleUpload(connectionInfo);
                        Action uploadAction = delegate()
                        {
                            upload.runUpload(cts.Token);
                        };
                        System.Threading.Tasks.Task task = new System.Threading.Tasks.Task(uploadAction);
                        task.Start();

                        server.task = task;
                        ServerListHelper.instance.UpdateServerInfo(server);
                    }
                    session.logout();
                    session = null;
                }
                catch (Exception exn)
                {
                    if (session != null)
                        session.logout();
                    log.Error(exn, exn);
                }
            }
        }

        public void updateCallHomeSettings(bool success, DateTime time, string uploadUuid = "")
        {
            Session session = new Session(connection.Hostname, 80);
            session.login_with_password(connection.Username, connection.Password);
            connection.LoadCache(session);

            // Round-trip format time
            DateTime rtime = DateTime.SpecifyKind(time, DateTimeKind.Utc);
            string stime = CallHomeSettings.DateTimeToString(rtime);

            // record upload_uuid,
            // release the lock,
            // set the time of LAST_SUCCESSFUL_UPLOAD or LAST_FAILED_UPLOAD
            Dictionary<string, string> config = Pool.get_health_check_config(session, connection.Cache.Pools[0].opaque_ref);
            config[CallHomeSettings.UPLOAD_LOCK] = "";
            if (success)
            {
                config[CallHomeSettings.LAST_SUCCESSFUL_UPLOAD] = stime;
                config[CallHomeSettings.UPLOAD_UUID] = uploadUuid;
            }
            else
                config[CallHomeSettings.LAST_FAILED_UPLOAD] = stime;
            Pool.set_health_check_config(session, connection.Cache.Pools[0].opaque_ref, config);

            if (session != null)
                session.logout();
            session = null;
        }

        // Test API for the harness
        public Dictionary<String, String> ListConsoles(String server, int port, String username, String password)
        {
            XenAPI.Session session = new Session(Session.STANDARD_TIMEOUT, server, port);
            Dictionary<String, String> dict = new Dictionary<String, String>();

            // Authenticate with username and password. The third parameter tells the server which API version we support.
            session.login_with_password(username, password, API_Version.LATEST);
            List<XenRef<XenAPI.Console>> consoleRefs = XenAPI.Console.get_all(session);
            foreach (XenRef<XenAPI.Console> consoleRef in consoleRefs)
            {
                XenAPI.Console console = XenAPI.Console.get_record(session, consoleRef);
                XenAPI.VM vm = XenAPI.VM.get_record(session, console.VM);
                dict.Add(vm.uuid, vm.name_label);
            }

            return dict;
        }

        public bool Connect(string server, int port, string vm_uuid, string username, string password, int width, int height, bool show_border)
        {
            // reinitiailize the VNC Control
            initSubControl(width, height, true, show_border);
            m_vncClient.ErrorOccurred += ConnectionErrorHandler;

            try {
                // Create a new XenAPI session
                m_session = new Session(Session.STANDARD_TIMEOUT, server, port);

                // Authenticate with username and password passed in. 
                // The third parameter tells the server which API version we support.
                m_session.login_with_password(username, password, API_Version.LATEST);
                m_vncPassword = password.ToCharArray();

                // Find the VM in question
                XenRef<VM> vmRef = VM.get_by_uuid(m_session, vm_uuid);
                m_sourceVM = VM.get_record(m_session, vmRef);

                // Check if this VM is PV or HVM
                m_sourceIsPV = (m_sourceVM.PV_bootloader.Length != 0); /* No PV bootloader specified implies HVM */

                // Get the console that uses the RFB (VNC) protocol
                List<XenRef<XenAPI.Console>> consoleRefs = VM.get_consoles(m_session, vmRef);
                XenAPI.Console console = null;
                foreach (XenRef<XenAPI.Console> consoleRef in consoleRefs)
                {
                    console = XenAPI.Console.get_record(m_session, consoleRef);
                    if (console.protocol == console_protocol.rfb)
                        break;
                    console = null;
                }

                if (console != null)
                    //ThreadPool.QueueUserWorkItem(new WaitCallback(ConnectToConsole), new KeyValuePair<VNCGraphicsClient, XenAPI.Console>(m_vncClient, console));
                    ConnectHostedConsole(m_vncClient, console, m_session.uuid);

                // done with this session, log it out
                m_session.logout();
            }
            catch (Exception exn)
            {
                // call the expcetion handler directly
                this.ConnectionErrorHandler(this, exn);
            }
            return m_vncClient.Connected;
        }