~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: moving to a component based architecture</title>

</head>

<h1 class="title">The Evolution of Finger: moving to a component based architecture</h1>

<div class="toc"><ol><li><a href="#auto0">Introduction</a></li><li><a href="#auto1">Write Maintainable Code</a></li><li><a href="#auto2">Advantages of Latest Version</a></li><li><a href="#auto3">Aspect-Oriented Programming</a></li></ol></div>

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

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

In this section of the tutorial, we'll move our code to a component

architecture so that adding new features is trivial.

See <a href="../components.html" shape="rect">Interfaces and Adapters</a> for a more

complete discussion of components.

<h2>Write Maintainable Code<a name="auto1"/></h2>

In the last version, the service class was three times longer than

any other class, and was hard to understand. This was because it turned

out to have multiple responsibilities. It had to know how to access

user information, by rereading the file every half minute,

but also how to display itself in a myriad of protocols. Here, we

used the component-based architecture that Twisted provides to achieve

a separation of concerns. All the service is responsible for, now,

is supporting getUser/getUsers. It declares its support via a call to

zope.interface.implements. Then, adapters are used to make this service

look like an appropriate class for various things: for supplying

a finger factory to TCPServer, for supplying a resource to site's

constructor, and to provide an IRC client factory for TCPClient.

All the adapters use are the methods in FingerService they are

declared to use: getUser/getUsers. We could, of course,

skip the interfaces and let the configuration code use

things like FingerFactoryFromService(f) directly. However, using

interfaces provides the same flexibility inheritance gives: future

subclasses can override the adapters.

<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

100

145

101

146

102

147

103

148

104

149

105

150

106

151

107

152

108

153

109

154

110

155

111

156

112

157

113

158

114

159

115

160

116

161

117

162

118

163

119

164

120

165

121

166

122

167

123

168

124

169

125

170

126

171

127

172

128

173

129

174

130

175

131

176

132

177

133

178

134

179

135

180

136

181

137

182

138

183

139

184

140

185

141

186

142

187

143

188

144

189

145

190

146

191

147

192

148

193

149

194

150

195

151

196

152

197

153

198

154

199

155

200

156

201

157

202

158

203

159

204

160

205

161

206

162

207

163

208

164

209

165

210

166

211

167

212

168

213

169

214

170

215

171

216

172

217

173

218

174

219

175

220

176

221

177

222

178

223

179

224

180

225

181

226

182

227

183

228

184

229

185

230

186

231

187

232

188

233

189

234

190

235

191

236

192

237

193

238

194

239

195

240

196

241

197

242

198

243

199

244

200

245

201

246

202

247

203

248

204

249

205

250

206

251

207

252

208

253

209

254

210

255

211

256

212

257

213

258

214

259

215

260

216

261

217

262

218

263

219

264

220

265

221

266

222

267

223

268

224

269

225

270

226

271

227

272

228

273

229

274

230

275

231

276

232

277

233

278

234

279

235

280

236

281

237

282

238

283

# Do everything properly, and componentize

284

from twisted.application import internet, service

285

from twisted.internet import protocol, reactor, defer

286

from twisted.words.protocols import irc

287

from twisted.protocols import basic

288

from twisted.python import components

289

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

290

from zope.interface import Interface, implements

291

import cgi

292

293

class IFingerService(Interface):

294

295

def getUser(user):

296

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

297

298

def getUsers():

299

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

300

301

class IFingerSetterService(Interface):

302

303

def setUser(user, status):

304

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

305

306

def catchError(err):

307

return "Internal error in server"

308

309

class FingerProtocol(basic.LineReceiver):

310

311

def lineReceived(self, user):

312

d = self.factory.getUser(user)

313

d.addErrback(catchError)

314

def writeValue(value):

315

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

316

self.transport.loseConnection()

317

d.addCallback(writeValue)

318

319

320

class IFingerFactory(Interface):

321

322

def getUser(user):

323

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

324

325

def buildProtocol(addr):

326

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

327

328

329

class FingerFactoryFromService(protocol.ServerFactory):

330

331

implements(IFingerFactory)

332

333

protocol = FingerProtocol

334

335

def __init__(self, service):

336

self.service = service

337

338

def getUser(self, user):

339

return self.service.getUser(user)

340

341

components.registerAdapter(FingerFactoryFromService,

342

IFingerService,

343

IFingerFactory)

344

345

class FingerSetterProtocol(basic.LineReceiver):

346

347

def connectionMade(self):

348

self.lines = []

349

350

def lineReceived(self, line):

351

self.lines.append(line)

352

353

def connectionLost(self, reason):

354

if len(self.lines) == 2:

355

self.factory.setUser(*self.lines)

356

357

358

class IFingerSetterFactory(Interface):

359

360

def setUser(user, status):

361

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

362

363

def buildProtocol(addr):

364

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

365

366

367

class FingerSetterFactoryFromService(protocol.ServerFactory):

368

369

implements(IFingerSetterFactory)

370

371

protocol = FingerSetterProtocol

372

373

def __init__(self, service):

374

self.service = service

375

376

def setUser(self, user, status):

377

self.service.setUser(user, status)

378

379

380

components.registerAdapter(FingerSetterFactoryFromService,

381

IFingerSetterService,

382

IFingerSetterFactory)

383

384

class IRCReplyBot(irc.IRCClient):

385

386

def connectionMade(self):

387

self.nickname = self.factory.nickname

388

irc.IRCClient.connectionMade(self)

389

390

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

391

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

392

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

393

394

d.addErrback(catchError)

395

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

396

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

397

398

399

class IIRCClientFactory(Interface):

400

401

"""

402

@ivar nickname

403

"""

404

405

def getUser(user):

406

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

407

408

def buildProtocol(addr):

409

"""Return a protocol"""

410

411

412

class IRCClientFactoryFromService(protocol.ClientFactory):

413

414

implements(IIRCClientFactory)

415

416

protocol = IRCReplyBot

417

nickname = None

418

419

def __init__(self, service):

420

self.service = service

421

422

def getUser(self, user):

423

424

425

components.registerAdapter(IRCClientFactoryFromService,

426

IFingerService,

427

IIRCClientFactory)

428

429

class UserStatusTree(resource.Resource):

430

431

implements(resource.IResource)

432

433

def __init__(self, service):

434

resource.Resource.__init__(self)

435

self.service = service

436

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

437

438

def render_GET(self, request):

439

d = self.service.getUsers()

440

def formatUsers(users):

441

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

442

for user in users]

443

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

444

d.addCallback(formatUsers)

445

d.addCallback(request.write)

446

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

447

return server.NOT_DONE_YET

448

449

def getChild(self, path, request):

450

if path=="":

451

return UserStatusTree(self.service)

452

else:

453

return UserStatus(path, self.service)

454

455

components.registerAdapter(UserStatusTree, IFingerService,

456

resource.IResource)

457

458

class UserStatus(resource.Resource):

459

460

def __init__(self, user, service):

461

resource.Resource.__init__(self)

462

self.user = user

463

self.service = service

464

465

def render_GET(self, request):

466

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

467

d.addCallback(cgi.escape)

468

d.addCallback(lambda m:

469

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

470

d.addCallback(request.write)

471

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

472

return server.NOT_DONE_YET

473

474

475

class UserStatusXR(xmlrpc.XMLRPC):

476

477

def __init__(self, service):

478

xmlrpc.XMLRPC.__init__(self)

479

self.service = service

480

481

def xmlrpc_getUser(self, user):

482

483

484

485

class FingerService(service.Service):

486

487

implements(IFingerService)

488

489

def __init__(self, filename):

490

self.filename = filename

491

self.users = {}

492

self._read()

493

494

def _read(self):

495

self.users.clear()

496

for line in file(self.filename):

497

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

498

user = user.strip()

499

status = status.strip()

500

self.users[user] = status

501

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

502

503

def getUser(self, user):

504

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

505

506

def getUsers(self):

507

508

509

510

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

511

f = FingerService('/etc/users')

512

serviceCollection = service.IServiceCollection(application)

513

internet.TCPServer(79, IFingerFactory(f)

514

).setServiceParent(serviceCollection)

515

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

516

).setServiceParent(serviceCollection)

517

i = IIRCClientFactory(f)

518

i.nickname = 'fingerbot'

519

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

520

).setServiceParent(serviceCollection)

521

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

522

523

<h2>Advantages of Latest Version<a name="auto2"/></h2>

524

525

<ul>

526

<li>Readable -- each class is short</li>

527

<li>Maintainable -- each class knows only about interfaces</li>

528

<li>Dependencies between code parts are minimized</li>

529

<li>Example: writing a new IFingerService is easy</li>

530

</ul>

531

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

532

533

534

535

536

537

538

539

540

541

542

543

544

545

546

547

548

549

550

551

552

553

554

555

556

557

558

559

560

class IFingerSetterService(Interface):

561

562

def setUser(user, status):

563

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

564

565

# Advantages of latest version

566

567

class MemoryFingerService(service.Service):

568

569

implements([IFingerService, IFingerSetterService])

570

571

def __init__(self, **kwargs):

572

self.users = kwargs

573

574

def getUser(self, user):

575

576

577

def getUsers(self):

578

579

580

581

self.users[user] = status

582

583

584

f = MemoryFingerService(moshez='Happy and well')

585

586

internet.TCPServer(1079, IFingerSetterFactory(f), interface='127.0.0.1'

587

).setServiceParent(serviceCollection)

588

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

589

590

Full source code here: <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

624

625

626

627

628

629

630

631

632

633

634

635

636

637

638

639

640

641

642

643

644

645

646

647

648

649

650

651

652

653

654

655

656

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

100

690

101

691

102

692

103

693

104

694

105

695

106

696

107

697

108

698

109

699

110

700

111

701

112

702

113

703

114

704

115

705

116

706

117

707

118

708

119

709

120

710

121

711

122

712

123

713

124

714

125

715

126

716

127

717

128

718

129

719

130

720

131

721

132

722

133

723

134

724

135

725

136

726

137

727

138

728

139

729

140

730

141

731

142

732

143

733

144

734

145

735

146

736

147

737

148

738

149

739

150

740

151

741

152

742

153

743

154

744

155

745

156

746

157

747

158

748

159

749

160

750

161

751

162

752

163

753

164

754

165

755

166

756

167

757

168

758

169

759

170

760

171

761

172

762

173

763

174

764

175

765

176

766

177

767

178

768

179

769

180

770

181

771

182

772

183

773

184

774

185

775

186

776

187

777

188

778

189

779

190

780

191

781

192

782

193

783

194

784

195

785

196

786

197

787

198

788

199

789

200

790

201

791

202

792

203

793

204

794

205

795

206

796

207

797

208

798

209

799

210

800

211

801

212

802

213

803

214

804

215

805

216

806

217

807

218

808

219

809

220

810

221

811

222

812

223

813

224

814

225

815

226

816

227

817

228

818

229

819

230

820

231

821

# Do everything properly, and componentize

822

823

824

825

826

827

828

829

import cgi

830

831

class IFingerService(Interface):

832

833

def getUser(user):

834

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

835

836

def getUsers():

837

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

838

839

class IFingerSetterService(Interface):

840

841

def setUser(user, status):

842

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

843

844

def catchError(err):

845

return "Internal error in server"

846

847

class FingerProtocol(basic.LineReceiver):

848

849

def lineReceived(self, user):

850

851

d.addErrback(catchError)

852

def writeValue(value):

853

854

self.transport.loseConnection()

855

d.addCallback(writeValue)

856

857

858

class IFingerFactory(Interface):

859

860

def getUser(user):

861

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

862

863

def buildProtocol(addr):

864

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

865

866

867

868

869

implements(IFingerFactory)

870

871

protocol = FingerProtocol

872

873

def __init__(self, service):

874

self.service = service

875

876

def getUser(self, user):

877

878

879

components.registerAdapter(FingerFactoryFromService,

880

IFingerService,

881

IFingerFactory)

882

883

class FingerSetterProtocol(basic.LineReceiver):

884

885

def connectionMade(self):

886

self.lines = []

887

888

def lineReceived(self, line):

889

self.lines.append(line)

890

891

def connectionLost(self, reason):

892

893

894

895

896

class IFingerSetterFactory(Interface):

897

898

def setUser(user, status):

899

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

900

901

def buildProtocol(addr):

902

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

903

904

905

906

907

implements(IFingerSetterFactory)

908

909

protocol = FingerSetterProtocol

910

911

def __init__(self, service):

912

self.service = service

913

914

915

916

917

918

components.registerAdapter(FingerSetterFactoryFromService,

919

IFingerSetterService,

920

IFingerSetterFactory)

921

922

class IRCReplyBot(irc.IRCClient):

923

924

def connectionMade(self):

925

926

irc.IRCClient.connectionMade(self)

927

928

929

930

931

932

d.addErrback(catchError)

933

934

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

935

936

937

class IIRCClientFactory(Interface):

938

939

"""

940

@ivar nickname

941

"""

942

943

def getUser(user):

944

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

945

946

def buildProtocol(addr):

947

"""Return a protocol"""

948

949

950

951

952

implements(IIRCClientFactory)

953

954

protocol = IRCReplyBot

955

nickname = None

956

957

def __init__(self, service):

958

self.service = service

959

960

def getUser(self, user):

961

962

963

components.registerAdapter(IRCClientFactoryFromService,

964

IFingerService,

965

IIRCClientFactory)

966

967

class UserStatusTree(resource.Resource):

968

969

implements(resource.IResource)

970

971

def __init__(self, service):

972

resource.Resource.__init__(self)

973

self.service = service

974

975

976

def render_GET(self, request):

977

d = self.service.getUsers()

978

def formatUsers(users):

979

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

980

for user in users]

981

982

d.addCallback(formatUsers)

983

d.addCallback(request.write)

984

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

985

return server.NOT_DONE_YET

986

987

988

if path=="":

989

return UserStatusTree(self.service)

990

else:

991

992

993

994

resource.IResource)

995

996

class UserStatus(resource.Resource):

997

998

999

resource.Resource.__init__(self)

1000

self.user = user

1001

self.service = service

1002

1003

def render_GET(self, request):

1004

1005

d.addCallback(cgi.escape)

1006

d.addCallback(lambda m:

1007

1008

d.addCallback(request.write)

1009

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

1010

return server.NOT_DONE_YET

1011

1012

1013

class UserStatusXR(xmlrpc.XMLRPC):

1014

1015

def __init__(self, service):

1016

xmlrpc.XMLRPC.__init__(self)

1017

self.service = service

1018

1019

def xmlrpc_getUser(self, user):

1020

1021

1022

class MemoryFingerService(service.Service):

1023

1024

implements([IFingerService, IFingerSetterService])

1025

1026

def __init__(self, **kwargs):

1027

self.users = kwargs

1028

1029

def getUser(self, user):

1030

1031

1032

def getUsers(self):

1033

1034

1035

1036

self.users[user] = status

1037

1038

1039

1040

f = MemoryFingerService(moshez='Happy and well')

1041

1042

1043

).setServiceParent(serviceCollection)

1044

1045

).setServiceParent(serviceCollection)

1046

i = IIRCClientFactory(f)

1047

i.nickname = 'fingerbot'

1048

1049

).setServiceParent(serviceCollection)

1050

1051

).setServiceParent(serviceCollection)

1052

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

1053

1054

1055

<h2>Aspect-Oriented Programming<a name="auto3"/></h2>

1056

1057

At last, an example of aspect-oriented programming that isn't about logging

1058

or timing. This code is actually useful! Watch how aspect-oriented programming

1059

helps you write less code and have fewer dependencies!

1060

1061

1062

1063

</div>

1064

1065

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

1066

Version: 10.0.0

1067

</body>

1068

</html>

b'\\ No newline at end of file'

Older »