~justin-fathomdb/nova/justinsb-openstack-api-volumes

<?xml version="1.0" encoding="utf-8"?><!DOCTYPE html PUBLIC '-//W3C//DTD XHTML 1.0 Transitional//EN' 'http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd'><html lang="en" xmlns="http://www.w3.org/1999/xhtml">

<head>

<title>Twisted Documentation: The Evolution of Finger: pluggable backends</title>

</head>

<h1 class="title">The Evolution of Finger: pluggable backends</h1>

<div class="toc"><ol><li><a href="#auto0">Introduction</a></li><li><a href="#auto1">Another Back-end</a></li><li><a href="#auto2">Yet Another Back-end: Doing the Standard Thing</a></li></ol></div>

<h2>Introduction<a name="auto0"/></h2>

This is the fifth part of the Twisted tutorial <a href="index.html" shape="rect">Twisted from Scratch, or The Evolution of Finger</a>.

In this part we will add new several new backends to our finger service

using the component-based architecture developed in <a href="components.html" shape="rect">The Evolution of Finger: moving to a

component based architecture</a>. This will show just how convenient it is to

implement new back-ends when we move to a component based architecture. Note

that here we also use an interface we previously wrote, FingerSetterFactory,

by supporting one single method. We manage to preserve the service's ignorance

of the network.

<h2>Another Back-end<a name="auto1"/></h2>

<div class="py-listing"><pre> 1

from twisted.internet import protocol, reactor, defer, utils

import pwd

# Another back-end

class LocalFingerService(service.Service):

implements(IFingerService)

def getUser(self, user):

# need a local finger daemon running for this to work

return utils.getProcessOutput("finger", [user])

def getUsers(self):

return defer.succeed([])

f = LocalFingerService()

</pre><div class="caption">Source listing - <a href="listings/finger/finger19b_changes.py">listings/finger/finger19b_changes.py</a></div></div>

Full source code here: <div class="py-listing"><pre> 1

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

100

167

101

168

102

169

103

170

104

171

105

172

106

173

107

174

108

175

109

176

110

177

111

178

112

179

113

180

114

181

115

182

116

183

117

184

118

185

119

186

120

187

121

188

122

189

123

190

124

191

125

192

126

193

127

194

128

195

129

196

130

197

131

198

132

199

133

200

134

201

135

202

136

203

137

204

138

205

139

206

140

207

141

208

142

209

143

210

144

211

145

212

146

213

147

214

148

215

149

216

150

217

151

218

152

219

153

220

154

221

155

222

156

223

157

224

158

225

159

226

160

227

161

228

162

229

163

230

164

231

165

232

166

233

167

234

168

235

169

236

170

237

171

238

172

239

173

240

174

241

175

242

176

243

177

244

178

245

179

246

180

247

181

248

182

249

183

250

184

251

185

252

186

253

187

254

188

255

189

256

190

257

191

258

192

259

193

260

194

261

195

262

196

263

197

264

198

265

199

266

200

267

201

268

202

269

203

270

204

271

205

272

206

273

207

274

208

275

209

276

210

277

211

278

212

279

213

280

214

281

215

282

216

283

217

284

218

285

219

286

220

287

221

288

222

289

223

290

224

291

225

292

226

293

227

294

228

295

229

296

230

297

231

298

232

299

233

300

234

301

235

302

236

303

237

304

238

305

239

306

240

307

241

308

242

309

243

310

244

311

245

312

246

313

247

314

248

315

249

316

250

317

251

318

252

319

253

320

254

321

255

322

256

323

257

324

# Do everything properly, and componentize

325

from twisted.application import internet, service

326

from twisted.internet import protocol, reactor, defer, utils

327

from twisted.words.protocols import irc

328

from twisted.protocols import basic

329

from twisted.python import components

330

from twisted.web import resource, server, static, xmlrpc

331

from zope.interface import Interface, implements

332

import cgi

333

import pwd

334

335

class IFingerService(Interface):

336

337

def getUser(user):

338

"""Return a deferred returning a string"""

339

340

def getUsers():

341

"""Return a deferred returning a list of strings"""

342

343

class IFingerSetterService(Interface):

344

345

def setUser(user, status):

346

"""Set the user's status to something"""

347

348

class IFingerSetterService(Interface):

349

350

def setUser(user, status):

351

"""Set the user's status to something"""

352

353

def catchError(err):

354

return "Internal error in server"

355

356

class FingerProtocol(basic.LineReceiver):

357

358

def lineReceived(self, user):

359

d = self.factory.getUser(user)

360

d.addErrback(catchError)

361

def writeValue(value):

362

self.transport.write(value+'\r\n')

363

self.transport.loseConnection()

364

d.addCallback(writeValue)

365

366

367

class IFingerFactory(Interface):

368

369

def getUser(user):

370

"""Return a deferred returning a string"""

371

372

def buildProtocol(addr):

373

"""Return a protocol returning a string"""

374

375

376

class FingerFactoryFromService(protocol.ServerFactory):

377

378

implements(IFingerFactory)

379

380

protocol = FingerProtocol

381

382

def __init__(self, service):

383

self.service = service

384

385

def getUser(self, user):

386

return self.service.getUser(user)

387

388

components.registerAdapter(FingerFactoryFromService,

389

IFingerService,

390

IFingerFactory)

391

392

class FingerSetterProtocol(basic.LineReceiver):

393

394

def connectionMade(self):

395

self.lines = []

396

397

def lineReceived(self, line):

398

self.lines.append(line)

399

400

def connectionLost(self, reason):

401

if len(self.lines) == 2:

402

self.factory.setUser(*self.lines)

403

404

405

class IFingerSetterFactory(Interface):

406

407

def setUser(user, status):

408

"""Return a deferred returning a string"""

409

410

def buildProtocol(addr):

411

"""Return a protocol returning a string"""

412

413

414

class FingerSetterFactoryFromService(protocol.ServerFactory):

415

416

implements(IFingerSetterFactory)

417

418

protocol = FingerSetterProtocol

419

420

def __init__(self, service):

421

self.service = service

422

423

def setUser(self, user, status):

424

self.service.setUser(user, status)

425

426

427

components.registerAdapter(FingerSetterFactoryFromService,

428

IFingerSetterService,

429

IFingerSetterFactory)

430

431

class IRCReplyBot(irc.IRCClient):

432

433

def connectionMade(self):

434

self.nickname = self.factory.nickname

435

irc.IRCClient.connectionMade(self)

436

437

def privmsg(self, user, channel, msg):

438

user = user.split('!')[0]

439

if self.nickname.lower() == channel.lower():

440

441

d.addErrback(catchError)

442

d.addCallback(lambda m: "Status of %s: %s" % (msg, m))

443

d.addCallback(lambda m: self.msg(user, m))

444

445

446

class IIRCClientFactory(Interface):

447

448

"""

449

@ivar nickname

450

"""

451

452

def getUser(user):

453

"""Return a deferred returning a string"""

454

455

def buildProtocol(addr):

456

"""Return a protocol"""

457

458

459

class IRCClientFactoryFromService(protocol.ClientFactory):

460

461

implements(IIRCClientFactory)

462

463

protocol = IRCReplyBot

464

nickname = None

465

466

def __init__(self, service):

467

self.service = service

468

469

def getUser(self, user):

470

471

472

components.registerAdapter(IRCClientFactoryFromService,

473

IFingerService,

474

IIRCClientFactory)

475

476

class UserStatusTree(resource.Resource):

477

478

implements(resource.IResource)

479

480

def __init__(self, service):

481

resource.Resource.__init__(self)

482

self.service = service

483

self.putChild('RPC2', UserStatusXR(self.service))

484

485

def render_GET(self, request):

486

d = self.service.getUsers()

487

def formatUsers(users):

488

l = ['<li><a href="%s">%s</a></li>' % (user, user)

489

for user in users]

490

return '<ul>'+''.join(l)+'</ul>'

491

d.addCallback(formatUsers)

492

d.addCallback(request.write)

493

d.addCallback(lambda _: request.finish())

494

return server.NOT_DONE_YET

495

496

def getChild(self, path, request):

497

if path=="":

498

return UserStatusTree(self.service)

499

else:

500

return UserStatus(path, self.service)

501

502

components.registerAdapter(UserStatusTree, IFingerService,

503

resource.IResource)

504

505

class UserStatus(resource.Resource):

506

507

def __init__(self, user, service):

508

resource.Resource.__init__(self)

509

self.user = user

510

self.service = service

511

512

def render_GET(self, request):

513

d = self.service.getUser(self.user)

514

d.addCallback(cgi.escape)

515

d.addCallback(lambda m:

516

'<h1>%s</h1>'%self.user+'%s'%m)

517

d.addCallback(request.write)

518

d.addCallback(lambda _: request.finish())

519

return server.NOT_DONE_YET

520

521

522

class UserStatusXR(xmlrpc.XMLRPC):

523

524

def __init__(self, service):

525

xmlrpc.XMLRPC.__init__(self)

526

self.service = service

527

528

def xmlrpc_getUser(self, user):

529

530

531

532

class FingerService(service.Service):

533

534

implements(IFingerService)

535

536

def __init__(self, filename):

537

self.filename = filename

538

self.users = {}

539

self._read()

540

541

def _read(self):

542

self.users.clear()

543

for line in file(self.filename):

544

user, status = line.split(':', 1)

545

user = user.strip()

546

status = status.strip()

547

self.users[user] = status

548

self.call = reactor.callLater(30, self._read)

549

550

def getUser(self, user):

551

return defer.succeed(self.users.get(user, "No such user"))

552

553

def getUsers(self):

554

555

556

# Another back-end

557

558

class LocalFingerService(service.Service):

559

560

implements(IFingerService)

561

562

def getUser(self, user):

563

# need a local finger daemon running for this to work

564

565

566

def getUsers(self):

567

return defer.succeed([])

568

569

570

application = service.Application('finger', uid=1, gid=1)

571

f = LocalFingerService()

572

serviceCollection = service.IServiceCollection(application)

573

internet.TCPServer(79, IFingerFactory(f)

574

).setServiceParent(serviceCollection)

575

internet.TCPServer(8000, server.Site(resource.IResource(f))

576

).setServiceParent(serviceCollection)

577

i = IIRCClientFactory(f)

578

i.nickname = 'fingerbot'

579

internet.TCPClient('irc.freenode.org', 6667, i

580

).setServiceParent(serviceCollection)

581

</pre><div class="caption">Source listing - <a href="listings/finger/finger19b.tac">listings/finger/finger19b.tac</a></div></div>

582

583

584

We've already written this, but now we get more for less work:

585

the network code is completely separate from the back-end.

586

587

588

<h2>Yet Another Back-end: Doing the Standard Thing<a name="auto2"/></h2>

589

590

<div class="py-listing"><pre> 1

591

592

593

594

595

596

597

598

599

600

601

602

603

604

605

606

607

608

609

610

611

612

613

614

615

616

617

618

619

620

621

622

623

import pwd

624

import os

625

626

627

# Yet another back-end

628

629

class LocalFingerService(service.Service):

630

631

implements(IFingerService)

632

633

def getUser(self, user):

634

user = user.strip()

635

try:

636

entry = pwd.getpwnam(user)

637

except KeyError:

638

return defer.succeed("No such user")

639

try:

640

f = file(os.path.join(entry[5],'.plan'))

641

except (IOError, OSError):

642

return defer.succeed("No such user")

643

data = f.read()

644

data = data.strip()

645

f.close()

646

return defer.succeed(data)

647

648

def getUsers(self):

649

return defer.succeed([])

650

651

652

653

f = LocalFingerService()

654

</pre><div class="caption">Source listing - <a href="listings/finger/finger19c_changes.py">listings/finger/finger19c_changes.py</a></div></div>

655

656

Full source code here: <div class="py-listing"><pre> 1

657

658

659

660

661

662

663

664

665

666

667

668

669

670

671

672

673

674

675

676

677

678

679

680

681

682

683

684

685

686

687

688

689

690

691

692

693

694

695

696

697

698

699

700

701

702

703

704

705

706

707

708

709

710

711

712

713

714

715

716

717

718

719

720

721

722

723

724

725

726

727

728

729

730

731

732

733

734

735

736

737

738

739

740

741

742

743

744

745

746

747

748

749

750

751

752

753

754

755

100

756

101

757

102

758

103

759

104

760

105

761

106

762

107

763

108

764

109

765

110

766

111

767

112

768

113

769

114

770

115

771

116

772

117

773

118

774

119

775

120

776

121

777

122

778

123

779

124

780

125

781

126

782

127

783

128

784

129

785

130

786

131

787

132

788

133

789

134

790

135

791

136

792

137

793

138

794

139

795

140

796

141

797

142

798

143

799

144

800

145

801

146

802

147

803

148

804

149

805

150

806

151

807

152

808

153

809

154

810

155

811

156

812

157

813

158

814

159

815

160

816

161

817

162

818

163

819

164

820

165

821

166

822

167

823

168

824

169

825

170

826

171

827

172

828

173

829

174

830

175

831

176

832

177

833

178

834

179

835

180

836

181

837

182

838

183

839

184

840

185

841

186

842

187

843

188

844

189

845

190

846

191

847

192

848

193

849

194

850

195

851

196

852

197

853

198

854

199

855

200

856

201

857

202

858

203

859

204

860

205

861

206

862

207

863

208

864

209

865

210

866

211

867

212

868

213

869

214

870

215

871

216

872

217

873

218

874

219

875

220

876

221

877

222

878

223

879

224

880

225

881

226

882

227

883

228

884

229

885

230

886

231

887

232

888

233

889

234

890

235

891

236

892

237

893

238

894

239

895

240

896

241

897

242

898

243

899

244

900

245

901

246

902

247

903

248

904

249

905

250

906

251

907

252

908

253

909

254

910

255

911

256

912

257

913

258

914

259

915

260

916

261

917

262

918

263

919

264

920

265

921

266

922

267

923

268

924

269

925

# Do everything properly, and componentize

926

927

928

929

930

931

932

933

import cgi

934

import pwd

935

import os

936

937

class IFingerService(Interface):

938

939

def getUser(user):

940

"""Return a deferred returning a string"""

941

942

def getUsers():

943

"""Return a deferred returning a list of strings"""

944

945

class IFingerSetterService(Interface):

946

947

def setUser(user, status):

948

"""Set the user's status to something"""

949

950

class IFingerSetterService(Interface):

951

952

def setUser(user, status):

953

"""Set the user's status to something"""

954

955

def catchError(err):

956

return "Internal error in server"

957

958

class FingerProtocol(basic.LineReceiver):

959

960

def lineReceived(self, user):

961

962

d.addErrback(catchError)

963

def writeValue(value):

964

965

self.transport.loseConnection()

966

d.addCallback(writeValue)

967

968

969

class IFingerFactory(Interface):

970

971

def getUser(user):

972

"""Return a deferred returning a string"""

973

974

def buildProtocol(addr):

975

"""Return a protocol returning a string"""

976

977

978

979

980

implements(IFingerFactory)

981

982

protocol = FingerProtocol

983

984

def __init__(self, service):

985

self.service = service

986

987

def getUser(self, user):

988

989

990

components.registerAdapter(FingerFactoryFromService,

991

IFingerService,

992

IFingerFactory)

993

994

class FingerSetterProtocol(basic.LineReceiver):

995

996

def connectionMade(self):

997

self.lines = []

998

999

def lineReceived(self, line):

1000

self.lines.append(line)

1001

1002

def connectionLost(self, reason):

1003

1004

1005

1006

1007

class IFingerSetterFactory(Interface):

1008

1009

def setUser(user, status):

1010

"""Return a deferred returning a string"""

1011

1012

def buildProtocol(addr):

1013

"""Return a protocol returning a string"""

1014

1015

1016

1017

1018

implements(IFingerSetterFactory)

1019

1020

protocol = FingerSetterProtocol

1021

1022

def __init__(self, service):

1023

self.service = service

1024

1025

1026

1027

1028

1029

components.registerAdapter(FingerSetterFactoryFromService,

1030

IFingerSetterService,

1031

IFingerSetterFactory)

1032

1033

class IRCReplyBot(irc.IRCClient):

1034

1035

def connectionMade():

1036

1037

irc.IRCClient.connectionMade(self)

1038

1039

1040

1041

1042

1043

d.addErrback(catchError)

1044

1045

d.addCallback(lambda m: self.msg(user, m))

1046

1047

1048

class IIRCClientFactory(Interface):

1049

1050

"""

1051

@ivar nickname

1052

"""

1053

1054

def getUser(user):

1055

"""Return a deferred returning a string"""

1056

1057

def buildProtocol(addr):

1058

"""Return a protocol"""

1059

1060

1061

1062

1063

implements(IIRCClientFactory)

1064

1065

protocol = IRCReplyBot

1066

nickname = None

1067

1068

def __init__(self, service):

1069

self.service = service

1070

1071

def getUser(self, user):

1072

1073

1074

components.registerAdapter(IRCClientFactoryFromService,

1075

IFingerService,

1076

IIRCClientFactory)

1077

1078

class UserStatusTree(resource.Resource):

1079

1080

implements(resource.IResource)

1081

1082

def __init__(self, service):

1083

resource.Resource.__init__(self)

1084

self.service = service

1085

1086

1087

def render_GET(self, request):

1088

d = self.service.getUsers()

1089

def formatUsers(users):

1090

l = ['<li><a href="%s">%s</a></li>' % (user, user)

1091

for user in users]

1092

1093

d.addCallback(formatUsers)

1094

d.addCallback(request.write)

1095

d.addCallback(lambda _: request.finish())

1096

return server.NOT_DONE_YET

1097

1098

1099

if path=="":

1100

return UserStatusTree(self.service)

1101

else:

1102

1103

1104

1105

resource.IResource)

1106

1107

class UserStatus(resource.Resource):

1108

1109

1110

resource.Resource.__init__(self)

1111

self.user = user

1112

self.service = service

1113

1114

def render_GET(self, request):

1115

1116

d.addCallback(cgi.escape)

1117

d.addCallback(lambda m:

1118

1119

d.addCallback(request.write)

1120

d.addCallback(lambda _: request.finish())

1121

return server.NOT_DONE_YET

1122

1123

1124

class UserStatusXR(xmlrpc.XMLRPC):

1125

1126

def __init__(self, service):

1127

xmlrpc.XMLRPC.__init__(self)

1128

self.service = service

1129

1130

def xmlrpc_getUser(self, user):

1131

1132

1133

1134

class FingerService(service.Service):

1135

1136

implements(IFingerService)

1137

1138

def __init__(self, filename):

1139

self.filename = filename

1140

self.users = {}

1141

self._read()

1142

1143

def _read(self):

1144

self.users.clear()

1145

1146

1147

user = user.strip()

1148

status = status.strip()

1149

self.users[user] = status

1150

1151

1152

def getUser(self, user):

1153

1154

1155

def getUsers(self):

1156

1157

1158

# Yet another back-end

1159

1160

class LocalFingerService(service.Service):

1161

1162

implements(IFingerService)

1163

1164

def getUser(self, user):

1165

user = user.strip()

1166

try:

1167

entry = pwd.getpwnam(user)

1168

except KeyError:

1169

return defer.succeed("No such user")

1170

try:

1171

1172

except (IOError, OSError):

1173

return defer.succeed("No such user")

1174

data = f.read()

1175

data = data.strip()

1176

f.close()

1177

return defer.succeed(data)

1178

1179

def getUsers(self):

1180

return defer.succeed([])

1181

1182

1183

1184

f = LocalFingerService()

1185

1186

1187

).setServiceParent(serviceCollection)

1188

1189

).setServiceParent(serviceCollection)

1190

i = IIRCClientFactory(f)

1191

i.nickname = 'fingerbot'

1192

1193

).setServiceParent(serviceCollection)

1194

</pre><div class="caption">Source listing - <a href="listings/finger/finger19c.tac">listings/finger/finger19c.tac</a></div></div>

1195

1196

1197

Not much to say except that now we

1198

can be churn out backends like crazy. Feel like doing a back-end

1199

for Advogato, for example? Dig out the XML-RPC client support Twisted

1200

has, and get to work!

1201

1202

</div>

1203

1204

<a href="../index.html">Index</a>

1205

Version: 10.0.0

1206

</body>

1207

</html>

b'\\ No newline at end of file'

Older »