Example #1
0
        public override void ExecuteCmdlet()
        {
            if (ShouldProcess(Instance, Resources.RestartingAnalysisServicesServer))
            {
                var context = AsAzureClientSession.Instance.Profile.Context;
                AsAzureClientSession.Instance.Login(context, null);

                var accessToken = TokenCacheItemProvider.GetTokenFromTokenCache(AsAzureClientSession.TokenCache, context.Account.UniqueId);

                var restartBaseUri = new Uri($"{Uri.UriSchemeHttps}{Uri.SchemeDelimiter}{context.Environment.Name}");

                var restartEndpoint = string.Format((string)context.Environment.Endpoints[AsAzureEnvironment.AsRolloutEndpoints.RestartEndpointFormat], _serverName);

                using (var message = AsAzureHttpClient.CallPostAsync(
                           restartBaseUri,
                           restartEndpoint,
                           accessToken).Result)
                {
                    message.EnsureSuccessStatusCode();
                    if (PassThru.IsPresent)
                    {
                        WriteObject(true);
                    }
                }
            }
        }
Example #2
0
        protected override void BeginProcessing()
        {
            base.BeginProcessing();

            if (AsAzureClientSession.Instance.Profile.Environments.Count == 0)
            {
                throw new PSInvalidOperationException(string.Format(Resources.NotLoggedInMessage, ""));
            }

            _serverName = Instance;
            Uri uriResult;

            // if the user specifies the FQN of the server, then extract the server name out of that.
            // and set the current context
            if (Uri.TryCreate(Instance, UriKind.Absolute, out uriResult) && uriResult.Scheme == "asazure")
            {
                _serverName = uriResult.PathAndQuery.Trim('/');
                if (string.Compare(AsAzureClientSession.Instance.Profile.Context.Environment.Name, uriResult.DnsSafeHost, StringComparison.InvariantCultureIgnoreCase) != 0)
                {
                    AsAzureClientSession.Instance.SetCurrentContext(
                        new AsAzureAccount(),
                        AsAzureClientSession.Instance.Profile.CreateEnvironment(uriResult.DnsSafeHost));
                }
            }
            else
            {
                var currentContext = AsAzureClientSession.Instance.Profile.Context;
                if (currentContext != null &&
                    AsAzureClientSession.AsAzureRolloutEnvironmentMapping.ContainsKey(currentContext.Environment.Name))
                {
                    throw new PSInvalidOperationException(string.Format(Resources.InvalidServerName, _serverName));
                }
            }

            if (AsAzureHttpClient == null)
            {
                AsAzureHttpClient = new AsAzureHttpClient(() => new HttpClient());
            }

            if (TokenCacheItemProvider == null)
            {
                TokenCacheItemProvider = new TokenCacheItemProvider();
            }
        }
Example #3
0
        public override void ExecuteCmdlet()
        {
            if (ShouldProcess(Instance, Resources.ExportingLogFromAnalysisServicesServer))
            {
                var context = AsAzureClientSession.Instance.Profile.Context;
                AsAzureClientSession.Instance.Login(context, null);

                var accessToken = TokenCacheItemProvider.GetTokenFromTokenCache(
                    AsAzureClientSession.TokenCache, context.Account.UniqueId);

                var logfileBaseUri = new Uri($"{Uri.UriSchemeHttps}{Uri.SchemeDelimiter}{context.Environment.Name}");

                var resolvedUriBuilder = new UriBuilder(logfileBaseUri)
                {
                    Host = ClusterResolve(logfileBaseUri, accessToken, _serverName)
                };

                var logfileEndpoint = string.Format(
                    (string)context.Environment.Endpoints[AsAzureEnvironment.AsRolloutEndpoints.LogfileEndpointFormat],
                    _serverName);

                AsAzureHttpClient.resetHttpClient();
                using (var message = AsAzureHttpClient.CallGetAsync(
                           resolvedUriBuilder.Uri,
                           logfileEndpoint,
                           accessToken).ConfigureAwait(false).GetAwaiter().GetResult())
                {
                    message.EnsureSuccessStatusCode();
                    var actionWarning = string.Format(CultureInfo.CurrentCulture, Resources.ExportingLogOverwriteWarning, OutputPath);
                    if (AzureSession.Instance.DataStore.FileExists(OutputPath) && !Force.IsPresent && !ShouldContinue(actionWarning, Resources.Confirm))
                    {
                        return;
                    }
                    AzureSession.Instance.DataStore.WriteFile(OutputPath, message.Content.ReadAsStringAsync().Result);
                }
            }
        }