Implementing a VMware Client with Extensible Records

by Matt Russell

What Makes up a Virtual Machine?

  • name
  • description
  • number of cpus
  • memory in megabytes
  • status (running, off, suspended, etc)
  • ....

Interacting with VMware

<retrievePropertiesRequest>
  <ref>vm-444</ref>
  <properties>
    <property>name</property>
    <property>hardware</property>
  </properties>
</retrievePropertiesRequest>

Request

Response

<retrievePropertiesResponse>
  <ref>vm-444</ref>
  <properties>
    <name>My-VM</name>
    <hardware>
      <numCpus>4</numCpus>
      <memoryMb>4096</memoryMb>
    </hardware>
  </properties>
</retrievePropertiesResponse>

What should our Virtual Machine (VM) API look like?

  • Express all of the possible VM fields
     
  • Query only for the fields we care about
     
  • Without Maybe for every field

 

Building Blocks of the VMware Client

  • Vinyl:  Extensible record library using type level lists

  • Composite: Group of libraries focusing on making extensible records easy to work with

  • HaXml: Utilities for parsing, filtering, transforming and generating XML documents


Our Virtual Machine Type

-- From Vinyl
data Rec :: (u -> *) -> [u] -> * where
  RNil :: Rec f '[]
  (:&) :: !(f r) -> !(Rec f rs) -> Rec f (r ': rs)

-- From Composite
newtype (:->) (s :: Symbol) a = Val { getVal :: a }
pattern (:*:) :: a -> Rec Identity rs -> Rec Identity ((s :-> a) ': rs)
let vm1 :: Rec Identity '[Name, Description, Hardware]
    vm1 = "my-vm" :*: "Matt's awesome VM" :*: (Hardware 6 4096) :*: RNil

>>> view name vm1
>>> "my-vm" :: Text
type Name        = "name"        :-> Text
type Description = "description" :-> Text
type Hardware    = "hardware"    :-> Hardware

HaXml Schema Generation

class SchemaType a where
  parseSchemaType :: XMLParser a
  schemaTypeToXML :: a -> XMLContent

data Hardware = {
  numCpus  :: Int,
  memoryMb :: Int
}

instance SchemaType Hardware where
  parseSchemaType = ...
  schemaTypeToXML = ...

 Use HaXml to auto generate Haskell types from XSD files

Our Ideal API

let vm1 :: Rec Identity '[Name, Description, Hardware]
    vm1 = retrieveProperties "vm-444" (Proxy @'[Name, Description, Hardware])

    vm2 :: Rec Identity '[VMName, VMHardware]
    vm2 = retrieveProperties "vm-444" (Proxy @'[VMName, VMHardware]

-- description is a lens from the extensible record to the description field
>>> view description vm1
>>> "Matt's awesome VM"

>>> view description vm2 --- type error!

Retrieve properties takes a proxy for the fields we want to request

Implementing Retrieve Properties

-- From Vinyl
class RecApplicative rs where
  rpure :: (forall x. f x) -> Rec f rs

recordToList :: Rec (Const a) rs -> [a]

-- From Composite (slight oversimplification)
class ReifyNames (rs :: [*]) where
  reifyNames :: Rec f rs -> Rec (Const Text) rs

recFromProxy :: forall rs proxy . RecApplicative rs 
             => proxy rs -> Rec (Const ()) rs
recFromProxy _ = rpure $ Const ()

fieldNames :: forall rs proxy . (ReifyNames rs, RecApplicative rs, Functor f) 
           => proxy rs -> [Text]
fieldNames = recordToList . reifyNames . recFromProxy

>>>> fieldNames (Proxy @'[Name, Description, Hardware])
>>>> ["name", "description", "hardware"]

Determining the "names" of the fields

Implementing Retrieve Properties

class RecordParserFromSchema rs where
  recordParserFromSchema :: Rec XmlParser rs

instance forall s a (rs :: [*]) 
         . (KnownSymbol s, SchemaType a, RecordParserFromSchema rs) 
         => RecordParserFromSchema (s :-> a ': rs) where
  recordParserFromSchema = (Val <$> parseSchemaType) :& recordFromSchema

instance RecordParserFromSchema '[] where
  recordParserFromSchema = RNil

-- From Vinyl
rtraverse :: Applicative h 
          => (forall x. f x -> h (g x)) -> Rec f rs -> h (Rec g rs)

propertiesParser :: RecordParserFromSchema rs 
                 => proxy rs -> XmlParser (Rec Identity rs)
propertiesParser _ = rtraverse (Identity <$>) recordParserFromSchema

Determining the parsers of the fields

Implementing Retrieve Properties

propertiesParser :: RecordParserFromSchema rs 
                 => XmlParser (Rec Identity rs)

fieldNames       :: forall rs proxy 
                 . (ReifyNames rs, RecApplicative rs, Functor f) 
                 => proxy rs -> [Text]

retrieveProperties :: (RecordParserFromSchema rs, ReifyNames rs, RecApplicative rs) 
                   => proxy rs -> Text -> IO (Either ParseError (Rec Identity rs))
retrieveProperties p ref = do

  let requestFields  = fieldNames p
      responseParser = propertiesParser p

  resp <- sendRequest ref requestFields
  return (responseParser fieldNames)
  

Putting it all together

Other cool things in the VMware Client

  • References to VMs (and other objects) are newtypes with safe constructors
     
  • Type safety to ensure we can only request properties for fields on the objects
     
  • Using HaXml to autogenerate types and endpoints
     
  • Using Classy Lenses to work with VMware's OO API

Thank You!

 

Let's chat at ICFP!

 

or connect after:

matt@simspace.com

@mrussell247

 

Implementing a VMware Client with Extensible Records

By Matt Russell

Implementing a VMware Client with Extensible Records

  • 193
Loading comments...