convert pdf to image c# ghostscript : Add security to pdf document software application dll winforms html .net web forms O'Reilly%20-%20Python%20Cookbook51-part1480

13.4 Using XML-RPC with Medusa 
Credit: Jeff Bauer 
13.4.1 Problem 
You need to establish a distributed processing system and want to use the XML-RPC protocol.  
13.4.2 Solution 
The 
medusa
package lets you implement lightweight, highly scalable servers, even with old 
versions of Python. An XML-RPC handler is included in the Medusa distribution. Here is how 
you code a server with Medusa:  
# xmlrpc_server.py 
from socket import gethostname 
from medusa.xmlrpc_handler import xmlrpc_handler 
from medusa.http_server import http_server 
from medusa import asyncore 
class xmlrpc_server(xmlrpc_handler): 
# initializes and runs the server 
def _ _init_ _(self, host=None, port=8182): 
if host is None: 
host = gethostname(  ) 
hs = http_server(host, port) 
hs.install_handler(self) 
asyncore.loop(  ) 
# an example of a method to be exposed via the XML-RPC 
protocol 
def add(self, op1, op2): 
return op1 + op2 
# the infrastructure ("plumbing") to expose methods 
def call(self, method, params): 
print "call method: %s, params: %s" % (method, 
str(params)) 
if method == 'add': 
return apply(self.add, params) 
return "method not found: %s" % method 
if _ _name_ _ == '_ _main_ _': 
server = xmlrpc_server(  ) 
And here is an 
xmlrpclib
-based client of this server:  
# xmlrpc_client.py 
from socket import gethostname 
from xmlrpclib import Transport, dumps 
class xmlrpc_connection: 
Add security to pdf document - C# PDF Digital Signature Library: add, remove, update PDF digital signatures in C#.net, ASP.NET, MVC, WPF
Help to Improve the Security of Your PDF File by Adding Digital Signatures
decrypt pdf file online; copy text from encrypted pdf
Add security to pdf document - VB.NET PDF Digital Signature Library: add, remove, update PDF digital signatures in vb.net, ASP.NET, MVC, WPF
Guide VB.NET Programmers to Improve the Security of Your PDF File by Adding Digital Signatures
pdf encryption; add security to pdf file
def _ _init_ _(self, host=None, port=8182): 
if host is None: 
host = gethostname(  ) 
self.host = "%s:%s" % (host, port) 
self.transport = Transport(  ) 
def remote(self, method, params=(  )): 
""" remote invokes the server with the method name 
and an optional set 
of parameters. The return value is always a tuple. 
""" 
response = self.transport.request(self.host, '/RPC2', 
dumps(params, 
method)) 
return response 
if _ _name_ _ == '_ _main_ _': 
connection = xmlrpc_connection(  ) 
(answer,) = connection.remote("add", (40, 2)) 
print "The answer is:", answer 
13.4.3 Discussion 
This recipe demonstrates remote method calls between two machines (or two processes, even on 
the same machine) using the XML-RPC protocol. A complete example of working client/server 
code is provided. XML-RPC is one of the easiest ways to handle distributed processing tasks. 
There's no messing around with the low-level socket details, nor is it necessary to write an 
interface definition. The protocol is platform- and language-neutral. The XML-RPC specification 
can be found at http://www.xml-rpc.com
and is well worth studying.  
With Medusa (http://www.nightmare.com
), you implement an XML-RPC server by subclassing 
the 
xmlrpc_handler
class and passing an instance of your class to the 
install_handler
method of an instance of 
http_server
. HTTP is the transport-level 
protocol, and 
http_server
handles all transport-level issues on your behalf. You need to 
provide only the handler part by customizing 
xmlrpc_handler
through subclassing and 
method overriding. Specifically, you must override the 
call
method, which the Medusa 
framework calls on your instance with the name of the XML-RPC method being called, along 
with its parameters, as arguments. This is exactly what we do in this recipe, in which we expose a 
single XML-RPC method named 
add
which accepts two numeric parameters and returns their 
sum as the method's result.  
The sample XML-RPC client uses 
xmlrpclib
in a more sophisticated way than Recipe 13.2
by using the 
Transport
class explicitly. This lets you see what happens under the covers of an 
XML-RPC method call a bit more transparently and also lets you control things in a finer-grained 
way, although we don't use that fine-grained-control potential in this recipe (and you will need it 
only rarely in XML-RPC clients that you actually deploy, anyway).  
xmlrpclib
can also be used on its own, without separately downloading and installing Medusa, 
and comes with similar client and server program examples. However, the asynchronous operation 
of Medusa can significantly enhance performance, particularly scalability. Medusa (and 
asyncore
and 
asynchat
) are applicable to client- and server-side programming, but this 
recipe does not use the asynchronous approach in its example client, only in its example server. Of 
course, the benefits of the asynchronous approach come when a program does several network 
VB.NET PDF Password Library: add, remove, edit PDF file password
On this page, we will illustrate how to protect PDF document via password by using simple VB.NET demo code. Add password to PDF. Set PDF security level.
create encrypted pdf; secure pdf remove
C# PDF Password Library: add, remove, edit PDF file password in C#
To help protect your PDF document in C# project, XDoc.PDF provides some PDF security settings. Add necessary references: RasterEdge.Imaging.Basic.dll.
create secure pdf; decrypt pdf online
operations at once (in such cases, asynchronous Medusa operations can give you substantial 
performance benefits when compared to alternatives such as multiprocessing and multithreading). 
This is almost always the case for servers, which need to be able to field several requests arriving 
simultaneously from different clients. It's certainly not unheard of for clients, too, if the client 
needs to make several requests at once.  
13.4.4 See Also 
The XML-RPC (
xmlrpclib
) library ships with recent versions of Python; if it isn't in your 
version of Python, you can get it from http://www.pythonware.com/products/xmlrpc/
; the Medusa 
library at http://www.nightmare.com
; recent Python releases include the 
asyncore
and 
asynchat
modules from Medusa as parts of the Python standard library (not, however, other 
parts of Medusa, such as 
xmlprc_handler
).  
C# HTML5 Viewer: Load, View, Convert, Annotate and Edit PDF
How to improve PDF document security. If you need to add your own signatures such as logo to PDF document, you and load and save it to current PDF file.
pdf unlock; secure pdf
C# HTML5 Viewer: Deployment on AzureCloudService
RasterEdge.XDoc.PDF.HTML5Editor.dll. 2. Add fill extension such as validateIntegratedModeConfiguration="false"/> <security> <requestFiltering
decrypt pdf file; pdf file security
13.5 Writing a Web Service That Supports Both XML-RPC 
and SOAP 
Credit: Graham Dumpleton 
13.5.1 Problem 
You need to expose a service on the Web in a way that makes the service accessible to both XML-
RPC and SOAP clients.  
13.5.2 Solution 
The OSE package offers a lot of extra flexibility for Python distributed processing, both server-
side and client-side. Here is how we can code the actual web service:  
# the actual web service, dbwebser.py 
# needs the OSE package from http://ose.sourceforge.net 
import netsvc 
import netsvc.xmlrpc 
import netsvc.soap 
import signal 
import dbm 
class Database(netsvc.Service): 
def _ _init_ _(self, name): 
netsvc.Service._ _init_ _(self, name) 
self._db = dbm.open(name,'c') 
self.exportMethod(self.get) 
self.exportMethod(self.put) 
self.exportMethod(self.keys) 
self.joinGroup("web-services") 
def get(self, key): 
return self._db[key] 
def put(self, key, value): 
self._db[key] = value 
def keys(self): 
return self._db.keys(  ) 
dispatcher = netsvc.Dispatcher(  ) 
dispatcher.monitor(signal.SIGINT) 
httpd = netsvc.HttpDaemon(8000) 
database = Database("test") 
rpcgw1 = netsvc.xmlrpc.RpcGateway("web-services") 
httpd.attach("/xmlrpc/database", rpcgw1) 
VB.NET PDF Page Extract Library: copy, paste, cut PDF pages in vb.
Security PDF component download. This .NET PDF Document Add-On integrates mature PDF document page processing functions, including extracting one or more page(s
copy locked pdf; change pdf document security
VB.NET PDF Library SDK to view, edit, convert, process PDF file
PDF Document Protection. XDoc.PDF SDK allows users to perform PDF document security settings in VB.NET program. Password, digital
convert locked pdf to word doc; decrypt pdf without password
rpcgw2 = netsvc.soap.RpcGateway("web-services") 
httpd.attach("/soap/database", rpcgw2) 
httpd.start(  ) 
dispatcher.run(  ) 
Here's a client that accesses the service via XML-RPC:  
# dbclient.py 
# an XML-RPC client using the PythonWare xmlrpclib module 
(also 
# included in the standard library with Python 2.2 and later) 
import xmlrpclib 
url = "http://localhost:8000/xmlrpc/database/test" 
service = xmlrpclib.Server(url) 
for i in range(10): 
service.put('X'+str(i), str(i*i)) 
for key in service.keys(  ): 
print key, service.get(key) 
And here's a SOAP client that uses the 
pywebsvcs
SOAP module:  
import SOAP 
url = "http://localhost:8000/soap/database/test" 
service = SOAP.SOAPProxy(url) 
for i in range(10): 
service.put('S'+str(i), str(i*i)) 
for key in service.keys(  ): 
print key, service.get(key) 
13.5.3 Discussion 
This recipe gives yet another example of an XML-RPC-capable web service. But this recipe is 
different in that the service can be accessed at the same time using the SOAP protocol. Confusion 
is avoided by having clients for each protocol use different URLs to access the service.  
The ability to support both XML-RPC and SOAP at the same time avoids the question of which to 
use. Only a single implementation of the service needs to be written. If one protocol wins out over 
the other, you haven't wasted any time; you simply don't deploy the gateway for the protocol you 
don't want to support anymore. Deploying both also gives users a wider choice of client 
implementations.  
Issues that arise in going down this road are that, since XML-RPC supports only positional 
parameters and not named parameters, you are reduced to using only positional parameters 
through the SOAP interface. There is also the problem that XML-RPC doesn't support the Python 
None
type, nor various other scalar data types that can be used with SOAP (e.g., extended date 
C# Image: C# Code to Upload TIFF File to Remote Database by Using
save the ImageUploadService file, add a web using System.Security.Cryptography; private void tsbUpload_Click profession imaging controls, PDF document, image to
add security to pdf document; change security settings pdf
VB.NET PDF - VB.NET HTML5 PDF Viewer Deployment on IIS
place where you store XDoc.PDF.HTML5 Viewer correspond site-> Edit Permissions -> Security -> Group or user names -> Edit -> Add -> Add Everyone usersgiven
convert locked pdf to word online; convert locked pdf to word
and time values). XML-RPC restricts you to using strings as key values in dictionaries that you 
wish to pass around using the protocol. What's worse is that SOAP further constrains what those 
key values can be, and SOAP cannot handle an empty dictionary.  
Thus, although it may be good to support both protocols, you are forced to use a set of data types 
and values that will work with both, which is a typical least-common-denominator syndrome 
similar to other cross-platform development efforts. In this case, the issue can be further 
complicated since some SOAP implementations may not preserve type information through to the 
server side, whereas in XML-RPC this is not a problem. Therefore, any server-side code may have 
to deal with values of specific types arriving in different forms. You need to run tests against a 
wide variety of clients to ensure that you've covered this ground.  
The 
netsvc
module used by this example comes with OSE, which can be found at 
http://ose.sourceforge.net
. The recipe's server script instantiates a 
Dispatcher
, an 
HttpDaemon
serving on port 8000, and two 
RpcGateway
instances, one from the 
soap
and one from the 
xmlrpc
module of OSE's 
netsvc
package. Both gateways expose the 
services from a group named 
web-services
, and we instantiate a single instance of our 
Database
class, a subclass of 
netsvc
's 
Service
class, which joins that group. Thus, the 
Database
instance implements all services that this server offers. Specifically, it does so by 
calling the 
exportMethod
method (which it gets from its base class) on each of its own bound 
methods it wants to expose as part of its initialization. Both SOAP and XML-RPC servers expose 
the same 
Database
instance via different URLs, and thus, both SOAP and XML-RPC clients 
end up accessing (and thus sharing) the same data structure.  
Note that the OSE package provides a framework for building distributed applications, of which 
this recipe represents only a small portion. The OSE package comes with its own XML-RPC 
protocol implementation, but for SOAP, it currently relies upon the SOAP module from the 
pywebsvcs
package, which can be found at http://sourceforge.net/projects/pywebsvcs
, along 
with an alternate set of modules worth exploring called the Zolera SOAP Infrastructure (ZSI).  
13.5.4 See Also 
Recipe 13.8
and Recipe 13.9
for different uses of OSE; the OSE package 
(http://ose.sourceforge.net
); the SOAP module from the 
pywebsvcs
package 
(http://sourceforge.net/projects/pywebsvcs
).  
13.6 Implementing a CORBA Client and Server 
Credit: Duncan Grisby 
13.6.1 Problem 
You need to implement a CORBA server and client to distribute a processing task, such as the all-
important network-centralized, fortune-cookie distribution.  
13.6.2 Solution 
CORBA is a mature object-oriented RPC protocol, and several CORBA ORBs offer excellent 
Python support. This recipe requires multiple files. Here is the interface definition file, fortune.idl:  
module Fortune { 
interface CookieServer { 
string get_cookie(  ); 
}; 
}; 
The server script is a simple Python program: 
import sys, os 
import CORBA, Fortune, Fortune_ _POA 
FORTUNE_PATH = "/usr/games/fortune" 
class CookieServer_i(Fortune_ _POA.CookieServer): 
def get_cookie(self): 
pipe   = os.popen(FORTUNE_PATH) 
cookie = pipe.read(  ) 
if pipe.close(  ): 
# An error occurred with the pipe 
cookie = "Oh dear, couldn't get a fortune\n" 
return cookie 
orb = CORBA.ORB_init(sys.argv) 
poa = orb.resolve_initial_references("RootPOA") 
servant = CookieServer_i(  ) 
poa.activate_object(servant) 
print orb.object_to_string(servant._this(  )) 
poa._get_the_POAManager().activate(  ) 
orb.run(  ) 
And here's a demonstration of the client code, using the Python interactive command line:  
>>> import CORBA, Fortune 
>>> orb = CORBA.ORB_init(  ) 
>>> o = orb.string_to_object( 
...   "corbaloc::host.example.com/fortune") 
>>> o = o._narrow(Fortune.CookieServer) 
>>> print o.get_cookie(  ) 
13.6.3 Discussion 
CORBA has a reputation for being hard to use, but it is really very easy, especially if you use 
Python. This example shows the complete CORBA implementation of a fortune-cookie server and 
its client. To run this example, you need a Python CORBA implementation (or two, as you can use 
two different CORBA implementations, one for the client and one for the server, and let them 
interoperate with the IIOP inter-ORB protocol). There are several free ones you can download.  
With most ORBs, you must convert the IDL interface definition into Python declarations with an 
IDL compiler. For example, with omniORBpy:  
$ omniidl -bpython fortune.idl 
This creates Python modules named 
Fortune
and 
Fortune_ _POA
to be used by clients 
and servers, respectively.  
In the server, we implement the 
CookieServer
CORBA interface by importing 
Fortune_ 
_POA
and subclassing the 
CookieServer
class that the module exposes. Specifically, in our 
own subclass, we need to override the 
get_cookie
method (i.e., implement the methods that 
the interface asserts we're implementing). Then, we start CORBA to get an 
orb
instance, ask the 
ORB for a 
POA
, instantiate our own interface-implementing object, and pass it to the 
POA
instance's 
activate_object
method. Finally, we call the 
activate
method on the POA 
manager and the 
run
method on the ORB to start our service.  
When you run the server, it prints out a long hex string, such as: 
IOR:010000001d00000049444c3a466f7274756e652f436f6f6b69655365
727665723 
a312e300000000001000000000000005c000000010102000d00000031353
82e313234 
2e36342e330000f90a07000000666f7274756e6500020000000000000008
000000010 
0000000545441010000001c0000000100000001000100010000000100010
509010100 
0100000009010100 
Printing this is the purpose of the 
object_to_string
call that our recipe's server performs 
just before it activates and runs.  
You have to give this value to the client's 
orb.string_to_object
call to contact your 
server. Of course, such long hex strings may not be very convenient to communicate to clients. To 
remedy this, it's easy to make your server support a simple 
corbaloc
URL string, like the one 
used in the client example, but this involves omniORB-specific code. (See the omniORBpy 
manual for details of 
corbaloc
URL support.)  
13.6.4 See Also 
omniORBpy at http://www.omniorb.org/omniORBpy/
.  
13.7 Performing Remote Logins Using telnetlib 
Credit: Jeff Bauer 
13.7.1 Problem 
You need to send commands to one or more logins that can be on the local machine or on a remote 
machine, and the Telnet protocol is acceptable.  
13.7.2 Solution 
Telnet is one of the oldest protocols in the TCP/IP stack, but it may still be serviceable (at least 
within an intranet that is well-protected against sniffing and spoofing attacks). In any case, 
Python's standard module 
telnetlib
supports Telnet quite well:  
# auto_telnet.py - remote control via telnet 
import os, sys, string, telnetlib 
from getpass import getpass 
class AutoTelnet: 
def _ _init_ _(self, user_list, cmd_list, **kw): 
self.host = kw.get('host', 'localhost') 
self.timeout = kw.get('timeout', 600) 
self.command_prompt = kw.get('command_prompt', "$ ") 
self.passwd = {} 
for user in user_list: 
self.passwd[user] = getpass("Enter user '%s' 
password: " % user) 
self.telnet = telnetlib.Telnet(  ) 
for user in user_list: 
self.telnet.open(self.host) 
ok = self.action(user, cmd_list) 
if not ok: 
print "Unable to process:", user 
self.telnet.close(  ) 
def action(self, user, cmd_list): 
t = self.telnet 
t.write("\n") 
login_prompt = "login: " 
response = t.read_until(login_prompt, 5) 
if string.count(response, login_prompt): 
print response 
else: 
return 0 
t.write("%s\n" % user) 
password_prompt = "Password:" 
response = t.read_until(password_prompt, 3) 
if string.count(response, password_prompt): 
print response 
else: 
return 0 
t.write("%s\n" % self.passwd[user]) 
response = t.read_until(self.command_prompt, 5) 
if not string.count(response, self.command_prompt): 
return 0 
for cmd in cmd_list: 
t.write("%s\n" % cmd) 
response = t.read_until(self.command_prompt, 
self.timeout) 
if not string.count(response, 
self.command_prompt): 
return 0 
print response 
return 1 
if _ _name_ _ == '_ _main_ _': 
basename = 
os.path.splitext(os.path.basename(sys.argv[0]))[0] 
logname = os.environ.get("LOGNAME", 
os.environ.get("USERNAME")) 
host = 'localhost' 
import getopt 
optlist, user_list = getopt.getopt(sys.argv[1:], 
'c:f:h:') 
usage = """ 
usage: %s [-h host] [-f cmdfile] [-c "command"] user1 
user2 ... 
-c  command 
-f  command file 
-h  host  (default: '%s') 
Example:  %s -c "echo $HOME" %s 
""" % (basename, host, basename, logname) 
if len(sys.argv) < 2: 
print usage 
sys.exit(1) 
cmd_list = [] 
for opt, optarg in optlist: 
if opt == '-f': 
for r in open(optarg).readlines(  ): 
if string.rstrip(r): 
cmd_list.append(r) 
elif opt == '-c': 
command = optarg 
if command[0] == '"' and command[-1] == '"': 
command = command[1:-1] 
cmd_list.append(command) 
elif opt == '-h': 
host = optarg 
autoTelnet = AutoTelnet(user_list, cmd_list, host=host) 
13.7.3 Discussion 
Documents you may be interested
Documents you may be interested