c# pdf viewer free : How to rearrange pages in pdf using reader software application cloud windows html winforms class Windows%20Powershell%20in%20Action%202nd%20Edition48-part1503

450
CHAPTER 12
R
EMOTING
AND
BACKGROUND
JOBS
The 
Invoke-Command
cmdlet is used to invoke a scriptblock on one or more com-
puters. You do so by specifying a computer name (or list of names) for the machines 
on which you want to execute the command. For each name in the list, the remoting 
subsystem will take care of all the details needed to open the connection to that com-
puter, execute the command, retrieve the results, and then shut down the connection. 
If you’re going to run the command on a large set of computers, 
Invoke-Command 
will also take care of all resource management details, such as limiting the number of 
concurrent remote connections.
This is a simple but powerful model if you only need to execute a single command 
or script on the target machine. But if you want to execute a series of commands on 
the target, the overhead of setting up and taking down a connection for each com-
mand becomes expensive. PowerShell remoting addresses this situation by allowing 
you to create a persistent connection to the remote computer called a session. You do 
so by using the 
New-PSSession
cmdlet.
Both of the scenarios we’ve discussed so far involve what is called noninteractive 
remoting because you’re just sending commands to the remote machines and then 
waiting for the results. You don’t interact with the remote commands while they’re 
executing.
Another standard pattern in remoting occurs when you want to set up an interac-
tive session where every command you type is sent transparently to the remote com-
puter. This is the style of remoting implemented by tools like Remote Desktop, telnet, 
or ssh (Secure Shell). PowerShell allows you to start an interactive session using the 
Enter-PSSession
cmdlet. Once you’ve entered a remote session, you can suspend 
the  session  without  closing  the  remote  connection  by  using 
Exit-PSSession
Because the connection isn’t closed, you can later reenter the session with all session 
data preserved by using 
Enter-PSSession
again.
These cmdlets—
Invoke-Command
New-PSSession
, and 
Enter-PSSession
— 
are the basic remoting tools you’ll be using. But before you can use them, you need to 
make sure remoting is enabled, so we’ll look at that next.
12.1.3
Enabling remoting
To satisfy the “secure by default” principle, before you can use PowerShell remoting 
to access a remote computer, the remoting service on that computer has to be explic-
itly enabled. You do so using the 
Enable-PSRemoting
cmdlet. To run this com-
mand, you have to have Administrator privileges on the machine you’re going to 
enable. From a PowerShell session that’s running with Administrator privileges, when 
you run the 
Enable-PSRemoting
command, the resulting sequence of interactions 
will look something like this:
PS C:\Windows\system32> Enable-PSRemoting 
WinRM Quick Configuration
How to rearrange pages in pdf using reader - re-order PDF pages in C#.net, ASP.NET, MVC, Ajax, WinForms, WPF
Support Customizing Page Order of PDF Document in C# Project
how to move pages around in a pdf document; move pdf pages
How to rearrange pages in pdf using reader - VB.NET PDF Page Move Library: re-order PDF pages in vb.net, ASP.NET, MVC, Ajax, WinForms, WPF
Sort PDF Document Pages Using VB.NET Demo Code
change page order pdf acrobat; how to rearrange pages in a pdf reader
G
ETTING
STARTED
WITH
REMOTING
451
Running command "Set-WSManQuickConfig" to enable this machine 
for remote management through WinRM service.
This includes:
1. Starting or restarting (if already started) the WinRM service
2. Setting the WinRM service type to auto start
3. Creating a listener to accept requests on any IP address
4. Enabling firewall exception for WS-Management traffic 
(for http only). 
Do you want to continue?
[Y] Yes  [A] Yes to All  [N] No  [L] No to All  [S] Suspend  
[?] Help (default is "Y"): y 
WinRM has been updated to receive requests.
WinRM service type changed successfully.
WinRM service started.
Configured LocalAccountTokenFilterPolicy to grant administrative 
rights remotely to local users.
WinRM has been updated for remote management.
Created a WinRM listener on HTTP://* to accept WS-Man requests to 
any IP on this machine.
WinRM firewall exception enabled.
PS C:\Windows\system32>
At various points in the process, you’ll be prompted to confirm each step. It’s worth 
spending a few minutes understanding what each step is doing because these opera-
tions have security implications for that computer. Click y (yes) to all these steps to 
make sure everything is enabled properly. (Once you’re comfortable with what’s being 
done, you can use the 
-Force
parameter to skip all the questions and just get it 
done.)  The 
Enable-PSRemoting
command performs all the configuration steps 
needed to allow users with local Administrator privileges to remote to this computer 
in a domain environment. In a nondomain or workgroup environment, as well as for 
nonadmin users, some additional steps are required for remoting to work.
12.1.4
Additional setup steps for workgroup environments
If you’re working in a workgroup environment (e.g., at home), you must take a few 
additional steps before you can connect to a remote machine. With no domain con-
troller available to handle the various aspects of security and identity, you have to 
manually configure the names of the computers you trust. For example, if you want 
to connect to the computer 
computerItrust
, then you have to add it to the list of 
trusted computers (or trusted hosts list). You can do this via the 
WSM
an: drive, as 
shown in table 12.2. Note that you need to be running as administrator to be able to 
use the 
WSM
an: provider.
Once  you’ve  completed  these  steps,  you’re  ready  to  start  playing  with  some 
examples.
C# TIFF: How to Reorder, Rearrange & Sort TIFF Pages Using C# Code
to enable C# users to reorder and rearrange multi-page Tiff Using this C#.NET Tiff image management library, you can of any two or more Tiff file pages or make
how to move pdf pages around; reorder pages in a pdf
VB.NET TIFF: Modify TIFF File by Adding, Deleting & Sort TIFF
you want to change or rearrange current TIFF &ltsummary> ''' Sort TIFF document pages in designed powerful & profession imaging controls, PDF document, image
how to rearrange pdf pages in preview; how to reorder pages in pdf online
452
CHAPTER 12
R
EMOTING
AND
BACKGROUND
JOBS
12.1.5
Enabling remoting in the enterprise
As you saw in the previous section, you enable PowerShell remoting on a single com-
puter using the 
Enable-PSRemoting
cmdlet. In the enterprise scenario, enabling 
machines one by one isn’t a great solution because you may be dealing with tens, hun-
dreds, or thousands of machines. Obviously, you can’t use PowerShell remoting to turn 
on remoting, so you need another way to push configuration out to a collection of 
machines. This is exactly what Group Policy is designed for. You can use Group Policy 
to enable and configure remoting as part of the machine policy that gets pushed out.
PowerShell depends on the 
W
in
RM
(Windows Remote Management) service for 
its operation. To enable the 
W
in
RM
listener on all computers in a domain, enable
Table 12.2 Additional steps needed to enable remote access to a computer in a workgroup
environment
Step
Command
Description
1
cd wsman:\localhost 
\client
Cd’ing into the client configuration node in the WSMan: 
drive allows you to access the WSMan configuration for 
this computer using the provider cmdlets.
2
$old = (Get-Item 
.\TrustedHosts).Value
You want to update the current value of the 
TrustedHosts item, so you get it and save the value 
in a variable.
3
$old += ',computerItrust' The value of TrustedHosts is a string containing a 
comma-separated list of the computers considered 
trustworthy. You add the new computer name to the 
end of this list, prefixed with a comma. (If you’re com-
fortable with implicitly trusting any host, then set this 
string to *, which matches any hostname.)
4
Set-Item 
.\TrustedHosts $old
Once you’ve verified that the updated contents of the 
variable are correct, you assign it back to the 
TrustedHosts item, which updates the configuration.
A note on security 
The  computers in the TrustedHosts list are implicitly trusted by adding  their 
names to this list. The identity of these computers won’t be authenticated when you 
connect to them. Because the connection process requires sending credential infor-
mation to these machines, you need to be sure that you can trust these computers. 
Also be aware that the TrustedHosts list on a machine applies to everyone who 
uses that computer, not just the user who changed the setting. 
That said, unless you allow random people to install computers on your internal net-
work, this shouldn’t introduce substantial risk most of the time. If you’re comfortable 
with  knowing  which  machines  you’ll  be  connecting  to,  you  can  put *  in  the 
TrustedHosts list, indicating that you’re implicitly trusting any computer you might 
be connecting to. As always, security is a principle tempered with pragmatics.
VB.NET Word: How to Process MS Word in VB.NET Library in .NET
well programmed Word pages sorter to rearrange Word pages in extracting single or multiple Word pages at one & profession imaging controls, PDF document, image
reorder pages of pdf; how to move pages within a pdf document
VB.NET PowerPoint: Sort and Reorder PowerPoint Slides by Using VB.
page will teach you to rearrange and readjust amount of robust PPT slides/pages editing methods and powerful & profession imaging controls, PDF document, image
how to reorder pages in pdf preview; how to rearrange pdf pages
G
ETTING
STARTED
WITH
REMOTING
453
the  Allow  Automatic  Configuration  of  Listeners  policy  in  the  following  Group 
Policy path:
Computer Configuration\Administrative Templates\Windows Components\ 
Windows Remote Management (WinRM)\WinRM service
This policy allows 
W
in
RM
to accept remoting requests. To enable a firewall exception 
for all computers in a domain, enable the Windows Firewall: Allow Local Port Excep-
tions policy in the following Group Policy path:
Computer Configuration\Administrative Templates\Network\ 
Network Connections\Windows Firewall\Domain Profile
This policy allows members of the Administrators group on the computer to use Win-
dows Firewall in Control Panel to create a firewall exception for the 
W
in
RM
service.
You also need to ensure that the 
W
in
RM
service is running on all machines you 
want to access. On server operating systems like Windows Server 2003, Windows 
Server 2008, and Windows Server 2008 R2, the startup type of the 
W
in
RM
service is 
set to Automatic by default, so nothing needs to be done for these environments. (This 
makes sense because the whole point of PowerShell is server management.) But on cli-
ent operating systems (
W
indows 
XP
, Windows Vista, and Windows 7), the 
W
in
RM 
service startup type is Disabled by default, so you need to start the service or change the 
startup type to Automatic before remote commands can be sent to these machines.
NOTE
Even if 
W
in
RM
isn’t  started, you  can still remote from  the 
machine—outbound connections don’t go through the 
W
in
RM
service. 
If you’re using a client machine and only want to connect from the client 
to the server, it makes sense to leave 
W
in
RM
disabled on this machine.
To change the startup type of a service on a remote computer, you can use the 
Set-
Service
cmdlet. This cmdlet can change the state of a service on a remote machine 
and doesn’t depend on the 
W
in
RM
service so it can be used to “bootstrap” remoting. 
Here’s an example showing how you’d do this for a set of computers. First, you need a 
list of the names of the computers on which to change the state. In this example, 
you’ll get the names from a text file:
PS (1) > $names = Get-Content MachineNames.txt
Now  you  can  pass  this list of names to the 
Set-Service
cmdlet to change the 
startup type of the 
W
in
RM
to Automatic:
PS (2) > Set-Service -Name WinRM -ComputerName $names ` 
>>> -Startuptype Automatic
To confirm the change, use the following command to display the 
StartMode
for the 
service (see section 19.2.2 for information on the 
Get-WmiObject
cmdlet):
PS (1) >  Get-WmiObject Win32_Service | 
>> where { $_.name -match "winrm" } |
C# PowerPoint - How to Process PowerPoint
Using our C#.NET PowerPoint processing control, you are move out useless PowerPoint document pages simply with solution to sort and rearrange PowerPoint slides
how to move pages in a pdf file; how to move pages in pdf converter professional
VB.NET PDF File & Page Process Library SDK for vb.net, ASP.NET
page directly. Moreover, when you get a PDF document which is out of order, you need to rearrange the PDF document pages. In these
reorder pdf pages in preview; reorder pages in pdf online
454
CHAPTER 12
R
EMOTING
AND
BACKGROUND
JOBS
>> Format-List displayname, startmode 
>>
displayname : Windows Remote Management (WS-Management) 
startmode   : Auto
At this point, you’ve done everything  necessary to enable remoting on the target 
machines, and you can get on with using the remoting feature to solve your remote 
management problems.
12.2
A
PPLYING
P
OWER
S
HELL
REMOTING
With remoting services enabled, you can start to use them to get your work done. In 
this section, we’re going to look at some of the ways you can apply remoting to solve 
management problems. We’ll start with some simple remoting examples. Next, we’ll 
work with some more complex examples where we introduce concurrent operations. 
Then you’ll apply the principles you’ve learned to solve a specific problem: how to 
implement a multimachine configuration monitor. You’ll work through this problem 
in a series of steps, adding more capabilities to your solution and resulting in a simple 
but fairly complete configuration monitor. Let’s start with the most basic examples.
12.2.1
Basic remoting examples
In chapter 1, you saw the most basic examples of remoting:
Invoke-Command Servername {"hello world"}
The first thing to notice is that 
Invoke-Command
takes a scriptblock to specify the 
actions. This  pattern  should be familiar by  now—you’ve seen  it  with 
ForEach-
Object
and 
Where-Object
many times. The 
Invoke-Command
does operate a bit 
differently, though. It’s designed to make remote execution as transparent as possible. 
For example, if you want to sort objects, the local command looks like this:
PS (1) > 1..3 | Sort -Descending 
1
Now if you want to do the sorting on the remote machine, you’d do this:
PS (2) > 1..3 | Invoke-Command localhost { Sort -Descending } 
1
You’re essentially splitting the pipeline across local and remote parts, and the script-
block is used to demarcate which part of the pipeline should be executed remotely. 
This works the other way as well:
PS (3) > Invoke-Command localhost { 1..3 } | sort -Descending 
1
Process Images in Web Image Viewer | Online Tutorials
used document types are supported, including PDF, multi-page easy to process image and file pages with the deleting a thumbnail, and you can rearrange the file
rearrange pdf pages reader; rearrange pdf pages
A
PPLYING
P
OWER
S
HELL
REMOTING
455
Here  you’re  generating  the  numbers on  the  remote  computer  and  sorting  them 
locally. Of course, scriptblocks can contain more than one statement. This implies 
that the semantics need to change a bit. Whereas in the simple pipeline case, stream-
ing input into the remote command was transparent, when the remote command 
contains more than one statement, you have to be explicit and use the 
$input
vari-
able to indicate where you want the input to go. This looks like the following:
PS (4) > 1..3 | Invoke-Command localhost { 
>> "First" 
>> $input | sort -Descending 
>> "Last" 
>> } 
>>
First 
Last
The scriptblock argument to 
Invoke-Command
in this case contains three statements. 
The first statement emits the string "First", the second statement does the sort on the 
input, and the third statement emits the string "Last". What happens if you don’t 
specify input? Let’s take a look:
PS (5) > 1..3 | Invoke-Command localhost { 
>> "First" 
>> Sort -Descending 
>> "Last" 
>> } 
>>
First 
Last
Nothing was emitted between "First" and "Last". Because 
$input
wasn’t specified, 
the input objects were never processed. You’ll need to keep this in mind when you 
start to build a monitoring solution. Now let’s look at how concurrency—multiple 
operations occurring at the same time—impacts your scripts.
12.2.2
Adding concurrency to the examples
In chapter 2, we talked about how each object passed completely through all states of 
a pipeline, one by one. This behavior changes with remoting because the local and 
remote commands run in separate processes that are executing concurrently. This 
means that you now have two threads of execution—local and remote—and this can 
have an effect on the order in which things are executed. Consider the following 
statement:
PS (12) > 1..3 | foreach { Write-Host $_; $_; Start-Sleep 5 } | 
>> Write-Host 
>> 
1
456
CHAPTER 12
R
EMOTING
AND
BACKGROUND
JOBS
3
This statement sends a series of numbers down the pipeline. In the body of the 
foreach
scriptblock, the value of the current pipeline object is written to the screen 
and then passed to the next state in the pipeline. This last stage also writes the object 
to the screen. Given that you know each object is processed completely by all stages of 
the pipeline, the order of the output is as expected. The first number is passed to the 
foreach
, where it’s displayed and then passed to 
Write-Output
, where it’s displayed 
again, so you see the sequence 1, 1, 2, 2, 3, 3. Now let’s run this command again 
using 
Invoke-Command
in the final stage:
PS (10) > 1..3 | foreach { 
>>   Write-Host -ForegroundColor cyan  $_ 
>>     $_; Start-Sleep 5 } | 
>>       Invoke-Command localhost  { Write-Host } 
>> 
3
Now the order has changed—you see 1 and 2 from the local process in cyan on a 
color display, then you see 1 from the remote process, and so on. The local and 
remote pipelines are executing at the same time, which is what’s causing the changes 
to the ordering. Predicting the order of the output is made more complicated by the 
use of buffering and timeouts in the remoting protocol, the details of which we’ll 
cover in chapter 13. 
You used the 
Start-Sleep
command in these examples to force these visible dif-
ferences. If you take out this command, you get a different pattern:
PS (13) > 1..3 | foreach { Write-Host $_; $_ } | 
>> Invoke-Command localhost { Write-Host } 
>> 
3
This time, all the local objects are displayed and then passed to the remoting layer, 
where they’re buffered until they can be delivered to the remote connection. This 
way, the local side can process all objects before the remote side starts to operate. 
Concurrent operation and buffering make it appear a bit unpredictable, but if you 
didn’t have the 
Write-Host
s in place, it’d be essentially unnoticeable. The important
A
PPLYING
P
OWER
S
HELL
REMOTING
457
thing to understand is that objects being sent to the remote end will be processed 
concurrently with the local execution. This means that the remoting infrastructure 
doesn’t have to buffer everything sent from the local end before starting execution.
Up to now, you’ve only been passing simple commands to the remote end. But 
because 
Invoke-Command
takes a scriptblock, you can, in practice, send pretty much 
any valid PowerShell script. You’ll take advantage of this fact in the next section 
when you start to build your multimachine monitor.
NOTE
So why does remoting require scriptblocks? There are a couple 
of reasons. First, scriptblocks are always compiled locally so you’ll catch 
syntax errors as soon as the script is loaded. Second, using scriptblocks 
limits vulnerability to code injection attacks by validating the script 
before sending it.
12.2.3
Solving a real problem: multimachine monitoring
In this section, you’re going to build a solution for a real management problem: mul-
timachine monitoring. With this solution, you’re going to gather some basic health 
information from the remote host. The goal is to use this information to determine 
when a server may have problems such as out of memory, out of disk, or reduced per-
formance due to a high faulting rate. You’ll gather the data on the remote host and 
return it as a hashtable so you can look at it locally.
Monitoring a single machine
To simplify things, you’ll start by writing a script that can work against a single host. 
The following listing shows this script.
$gatherInformation ={
@{
Date = Get-Date
FreeSpace = (Get-PSDrive c).Free
PageFaults = (Get-WmiObject `
Win32_PerfRawData_PerfOS_Memory).PageFaultsPersec
TopCPU = Get-Process | sort CPU -desc | select -First 5
TopWS = Get-Process | sort -desc WS | select -First 5
}
Invoke-Command servername $gatherInformation
This script uses a number of mechanisms to get the required data and returns the 
result as a hashtable. This hashtable contains the following pieces of performance-
related information:
• The amount of free space on the 
C:
drive from the 
Get-PSDrive
command
• The page fault rate retrieved using 
WMI
(see chapter 19)
Listing 12.1    Defining the data acquisition scriptblock
458
CHAPTER 12
R
EMOTING
AND
BACKGROUND
JOBS
• The processes consuming the most 
CPU
from 
Get-Process
with a pipeline
• The processes that have the largest working set, also from 
Get-Process
You write the information-gathering scriptblock in exactly the same way you’d write 
it for the local host—the fact that it’s being executed on another computer is entirely 
transparent. All you had to do was wrap the code in an extra set of braces and pass it 
to 
Invoke-Command
.
Monitoring multiple machines
Working against one machine was simple, but your goal was multimachine monitor-
ing. So you need to change the script to run against a list of computers. You don’t 
want to hardcode the list of computers in the script—that interferes with reuse—so 
you’ll design it to get the data from a file called servers.txt. The content of this file is a 
list of hostnames, one per line, which might look like this:
Server-sql-01
Server-sql-02 
Server-sql-03 
Server-Exchange-01 
Server-SharePoint-Markerting-01 
Server-Sharepoint-Development-01
Adding  this  functionality  requires  only  a  small,  one-line  change  to  the  call  to 
Invoke-Command
. This revised command looks like this:
Invoke-Command (Get-Content servers.txt) $gatherInformation
You could make this more complex—say you only wanted to scan certain computers 
on certain days. You’ll update the servers.txt file to be a 
CSV
file:
Name, Day
Server-sql-01,Monday 
Server-sql-02,Tuesday 
Server-sql-03,Wednesday 
Server-Exchange-01, Monday 
Server-SharePoint-Markerting-01, Wednesday 
Server-Sharepoint-Development-01, Friday
Now when you load the servers, you’ll do some processing on this list, which looks 
like this:
$servers = Import-CSV servers.csv |
where { $_.Day -eq (Get-Date).DayOfWeek } |
foreach { $_.Name }
Invoke-Command $servers $gatherInformation
There are still no changes required in the actual data-gathering code. Let’s move on to 
the next refinement.
Resource management using throttling
In a larger organization, this list of servers is likely to be quite large, perhaps hun-
dreds or even thousands of servers. Obviously it isn’t possible to establish this many
A
PPLYING
P
OWER
S
HELL
REMOTING
459
concurrent connections—doing so would exhaust the system resources. To manage 
the  amount of resources  consumed, you  can  use throttling.  In  general, throttling 
allows you to limit the amount of resources that an activity can consume at one 
time. In this case, you’re limiting the number of connections that command makes 
at one time. There’s a built-in throttle limit to prevent accidental resource exhaus-
tion. By default, 
Invoke-Command
will limit the number of concurrent connections 
to 32. To override this, use the 
-ThrottleLimit
parameter on 
Invoke-Command
to 
limit the number of connections. In this example you’re going to limit the number 
of concurrent connections to 10:
$servers = Import-CSV –Path servers.csv |
where { $_.Day -eq (Get-Date).DayOfWeek } |
foreach { $_.Name }
Invoke-Command -ThrottleLimit 10 –ComputerName $servers `
-ScriptBlock $gatherInformation
At this point, you’ll consolidate the incremental changes you’ve made and look at the 
updated script as a whole, as shown in the next listing.
$gatherInformation ={
@{
Date = Get-Date
FreeSpace = (Get-PSDrive c).Free
PageFaults = (Get-WmiObject `
Win32_PerfRawData_PerfOS_Memory).PageFaultsPersec
TopCPU = Get-Process | sort CPU -desc | select -First 5
TopWS = Get-Process | sort -desc WS | select -First 5
$servers = Import-CSV –Path servers.csv |
where { $_.Day -eq (Get-Date).DayOfWeek } |
foreach { $_.Name }
Invoke-Command -Throttle 10 –ComputerName $servers `
-ScriptBlock $gatherInformation
This has become a pretty capable script: it gathers a useful set of information from a 
network of servers in a manageable, scalable way. It’d be nice if you could generalize it 
a bit more so you could use different lists of servers or change the throttle limits. 
Parameterizing the solution
You can increase the flexibility of this tool by adding some parameters to it. Here are 
the parameters you want to add:
param (
[Parameter()]
[string] $ServerList = "servers.txt",
[Parameter()]
[int] $ThrottleLimit = 10,
[Parameter()]
Listing 12.2    Data acquisition script using servers.csv file
Documents you may be interested
Documents you may be interested