This document discusses building web service clients with ActiveModel. It notes that ActiveModel is used for building forms and interacting with data internally within requests. It then discusses how to abstract complexity when working with web services and external APIs. It provides examples of using ActiveModel features like callbacks, dirty tracking, errors, serialization, and validations to build client-side models. It also discusses techniques for making parallel API requests using libraries like EventMachine and Typhoeus to improve performance. The goal is to build readable and maintainable client-side code that can scale with both complexity and team size.

1. Building Web Service
Clients with
ActiveModel
Paul Dix
http://pauldix.net
@pauldix

2. IM Paul Dix
photo credit: Sebastian Delmont

4. I am a Ruby love
machine!

5. Web Services, duh!

6. ActiveModel

7. Web Services Abstract
Complexity

8. Scale

9. Scale with Complexity
PhOtOnQuAnTiQuE (http://www.flickr.com/photos/67968452@N00/1876685709/)

10. Scale with Team Size
alexkess (http://www.flickr.com/photos/34838158@N00/3370167184/)

11. Monolithic
American Backroom (http://www.flickr.com/photos/41922098@N03/4247207167/)

12. Split into Logical Parts

13. How ActiveResource
killed my best friend

14. Brian Hathcock (http://www.flickr.com/photos/22961976@N00/3040920714/)

15. Understandable Code

16. Client libraries goal:
readable and
maintainable code

17. Parallel Connections

18. Make Stubbing Easy for
Development

19. define:”Web Services”

20. External
Services

21. Internal
Services

22. ActiveModel is for use
with rails forms helpers
and other things. Things
that are only used inside
user requests.
Calls Inside User
Requests

23. focus(:internal_services)

24. Abstracting Complexity

25. Work with large code
base

26. Scale

27. Not Traffic

28. NoSQL is getting there

29. Code Complexity

30. Team Size

31. Examples

32. Processor

33. Operating System

34. MapReduce

35. Web Services?

36. Email Service

37. User Service

38. Haystack

39. Indexing

40. How to separate
functionality

41. Partition on Iteration
Speed

42. Partition on Logical
Fucntion

43. Partition on Read/Write
Frequencies

44. Partition on Join
Frequency

45. Goals

46. Denormalize and
Replicate

47. Separation of Concerns

48. Abstraction

49. ActiveResource and
ActiveRecord killed
these

50. Both make connections
inside the model

51. class Collect < Base
end
class ShippingAddress < Base
end
class BillingAddress < Base
end
class LineItem < Base
end
class ShippingLine < Base
end
class NoteAttribute < Base
end

52. lloydi (http://www.flickr.com/photos/58944004@N00/2362260604/)

53. class Collect < Base
end
class ShippingAddress < Base
end
class BillingAddress < Base
end
class LineItem < Base
end
class ShippingLine < Base
end
class NoteAttribute < Base
end

54. Makes requests serially

55. Requests in Parallel

56. ActiveModel

58. helpers for adding
prefixes and suffixes to
methods.... boring
AttributeMethods

59. Callbacks

60. class User
include ActiveModel::Callbacks
before_create :do_stuff
def create
# ...
end
def do_stuff
# ...
end
end

61. Dirty Tracking

62. class Person
include ActiveModel::Dirty
define_attribute_methods [:name]
def name
@name
end
def name=(val)
name_will_change!
@name = val
end
def save
@previously_changed = changes
end
end

63. # A newly instantiated object is unchanged:
person = Person.find_by_name('Uncle Bob')
person.changed? # => false

64. # Change the name:
person.name = 'Bob'
person.changed? # => true
person.name_changed? # => true
person.name_was # => 'Uncle Bob'
person.name_change # => ['Uncle Bob', 'Bob']
person.name = 'Bill'
person.name_change # => ['Uncle Bob', 'Bill']

65. # Save the changes:
person.save
person.changed? # => false
person.name_changed? # => false

66. # Assigning the same value leaves the
# attribute unchanged:
person.name = 'Bill'
person.name_changed? # => false
person.name_change # => nil

67. # Which attributes have changed?
person.name = 'Bob'
person.changed # => ['name']
person.changes # => {'name' => ['Bill', 'Bob']}

68. # Resetting an attribute returns it to
# its original state:
person.reset_name! # => 'Bill'
person.changed? # => false
person.name_changed? # => false
person.name # => 'Bill'

69. Errors

70. class User
def errors
@errors ||= ActiveModel::Errors.new(self)
end
def validate!
errors.add(:name, "can not be nil")
end
end
user.errors[:name] #=> ["can not be nil"]

71. Serialization

72. class User
include ActiveModel::Serialization
def attributes
{
:id => @id,
:name => @name,
:email => @email
}
end
end
user.to_json(:only => [:id, :name])
user.to_xml(:except => [:email])

73. Validations

74. class User
include ActiveModel::Validations
attr_reader :name, :email, :age,
:terms_of_service, :password,
:password_confirmation, :role
validates_acceptance_of :terms_of_service
end
user = User.new
puts user.valid?

75. class User
include ActiveModel::Validations
attr_reader :name, :email, :age,
:terms_of_service, :password,
:password_confirmation, :role
validates_confirmation_of :password
end
user = User.new
puts user.valid?

76. class User
include ActiveModel::Validations
attr_reader :name, :email, :age,
:terms_of_service, :password,
:password_confirmation, :role
validates_presence_of :name
end
user = User.new
puts user.valid?

77. class User
include ActiveModel::Validations
attr_reader :name, :email, :age,
:terms_of_service, :password,
:password_confirmation, :role
validates_exclusion_of :name,
:in => ["admin"]
end
user = User.new
puts user.valid?

78. class User
include ActiveModel::Validations
attr_reader :name, :email, :age,
:terms_of_service, :password,
:password_confirmation, :role
validates_inclusion_of :role,
:in => ["user", "admin"]
end
user = User.new
puts user.valid?

79. class User
include ActiveModel::Validations
attr_reader :name, :email, :age,
:terms_of_service, :password,
:password_confirmation, :role
validates_format_of :email,
:with => /A([^@s]+)@((?:[-a-z0-9]+.)+[a-z]{2,})Z/i
end
user = User.new
puts user.valid?

80. class User
include ActiveModel::Validations
attr_reader :name, :email, :age,
:terms_of_service, :password,
:password_confirmation, :role
validates_length_of :password, :minimum => 6
end
user = User.new
puts user.valid?

81. class User
include ActiveModel::Validations
attr_reader :name, :email, :age,
:terms_of_service, :password,
:password_confirmation, :role
validates_numericality_of :age
end
user = User.new
puts user.valid?

82. validates_uniqueness_of?

83. ehpien (http://www.flickr.com/photos/91499534@N00/343313257/)

84. Testing

85. require 'rubygems'
require 'active_model'
require 'test/unit'
require 'user'
class LintTest < ActiveModel::TestCase
include ActiveModel::Lint::Tests
def setup
@model = User.new
end
end

86. class User
include ActiveModel::Conversion
extend ActiveModel::Naming
def valid?() true end
def errors
@errors ||= ActiveModel::Errors.new(self)
end
def persisted?
true
end
end

87. Parallel Connections

88. Asynchronous

89. EventMachine

90. Curb

91. Typhoeus
Mushkush (http://www.flickr.com/photos/43002463@N00/2877016310/)

92. Quick Example

93. PauldixReadingList::ReadingList.for_user(
"paul",
:include => [:entry, :rating_total]) do |list|
reading_list = list
end
HYDRA.run
# now we can access the reading list
reading_list.entries.each do |entry|
puts entry.id
puts entry.title
puts entry.body
puts "up: #{entry.rating_total.up_count} |
down: #{entry.rating_total.down_count}nn"
end

94. def self.for_user(user_id, options = {}, &block)
includes = options[:include] || []
request =
Typhoeus::Request.new(get_by_id_uri(user_id))
request.on_complete do |response|
list = new(response.body, options)
list.request_entries if includes.include?(:entry)
list.request_rating_totals if
includes.include?(:rating_total)
block.call(list)
end
PauldixReadingList::Config.hydra.queue(request)
end

95. def self.get_ids(ids, &block)
request = Typhoeus::Request.new(get_ids_uri(ids))
request.on_complete do |response|
json = Yajl::Parser.parse(response.body)
entries = ids.map do |id|
new(json[id].merge("id" => id))
end
block.call(entries)
end
PauldixEntries::Config.hydra.queue(request)
end

96. def self.get_ids(ids, &block)
request = Typhoeus::Request.new(get_ids_uri(ids))
request.on_complete do |response|
json = Yajl::Parser.parse(response.body)
ratings = ids.map do |id|
new(json[id])
end
block.call(ratings)
end
PauldixRatings::Config.hydra.queue(request)
end

97. Gunnsi (http://www.flickr.com/photos/38735097@N00/440198755/)

98. Threaded

99. require 'net/http'
include Java
import 'java.util.concurrent.Executors'
class Request
include java.util.concurrent.Callable
def initialize(url)
@url = url
end
def call
Net::HTTP.get(URI.parse(@url))
end
end

100. thread_pool = Executors.new_fixed_thread_pool(50)
futures = []
100.times do |i|
request =
Request.new("http://localhost:3000/entries/#{i}")
futures << thread_pool.submit(request)
end
results = futures.map {|f| f.get}
# do something with results
thread_pool.shutdown

101. Keep Alive

102. Stubbing

103. Review

104. Readable Client Code

105. lloydi (http://www.flickr.com/photos/58944004@N00/2362260604/)

106. Models Build Requests

107. Parallel Connections

108. Validate Early

109. Easy Stubs

110. Abstract Complexity

111. Scale

112. Scale with Complexity
PhOtOnQuAnTiQuE (http://www.flickr.com/photos/67968452@N00/1876685709/)

113. Scale with Team Size
alexkess (http://www.flickr.com/photos/34838158@N00/3370167184/)

114. Monolithic
American Backroom (http://www.flickr.com/photos/41922098@N03/4247207167/)

115. Thanks!

116. Questions?