Safe Haskell	None

Keter.Types.Common

Synopsis

Documentation

type Appname = Text Source

Name of the application. Should just be the basename of the application file.

data Plugin Source

Constructors

Plugin
Fields pluginGetEnv :: Appname -> Object -> IO [(Text, Text)]

type Plugins = [Plugin]Source

class ToCurrent a whereSource

Used for versioning data types.

Associated Types

type Previous a Source

Methods

toCurrent :: Previous a -> aSource

Instances

ToCurrent RedirectConfig
ToCurrent StaticFilesConfig
ToCurrent KeterConfig
ToCurrent BundleConfig
ToCurrent a => ToCurrent (Maybe a)
ToCurrent (WebAppConfig ())

type Port = Int Source

A port for an individual app to listen on.

type Host = Text Source

A virtual host we want to serve content from.

type HostBS = ByteString Source

getAppname :: FilePath -> Text Source

logEx :: Q Exp Source

data AppId Source

Constructors

AIBuiltin
AINamed !Appname

Instances

Eq AppId
Ord AppId
Show AppId

data FilePath

Instances

Eq FilePath
Data FilePath
Ord FilePath
Show FilePath
Typeable FilePath
IsString FilePath
Monoid FilePath
NFData FilePath
ParseYamlFile FilePath

data Text

A space efficient, packed, unboxed Unicode text type.

Instances

Eq Text
Data Text
Ord Text
Read Text
Show Text
Typeable Text
IsString Text
ToJSON Text
FromJSON Text
Monoid Text
Hashable Text
FoldCase Text
NFData Text
~ * a Text => IsString (Parser a)
ToJSON v => ToJSON (HashMap Text v)
ToJSON v => ToJSON (Map Text v)
FromJSON v => FromJSON (HashMap Text v)
FromJSON v => FromJSON (Map Text v)

data ByteString

A space-efficient representation of a Word8 vector, supporting many efficient operations. A ByteString contains 8-bit characters only.

Instances of Eq, Ord, Read, Show, Data, Typeable

Instances

Eq ByteString
Data ByteString
Ord ByteString
Read ByteString
Show ByteString
Typeable ByteString
IsString ByteString
ToJSON ByteString
FromJSON ByteString
Monoid ByteString
Hashable ByteString
FoldCase ByteString	Note that `foldCase` on `ByteStrings` is only guaranteed to be correct for ISO-8859-1 encoded strings!
NFData ByteString
Extract ByteString
RegexLike Regex ByteString
RegexContext Regex ByteString ByteString
RegexMaker Regex CompOption ExecOption ByteString
~ * a ByteString => IsString (Parser a)
ToJSON v => ToJSON (HashMap ByteString v)
ToJSON v => ToJSON (Map ByteString v)
FromJSON v => FromJSON (HashMap ByteString v)
FromJSON v => FromJSON (Map ByteString v)

data Set a

A set of values a.

Instances

Typeable1 Set
Foldable Set
Eq a => Eq (Set a)
(Data a, Ord a) => Data (Set a)
Ord a => Ord (Set a)
(Read a, Ord a) => Read (Set a)
Show a => Show (Set a)
ToJSON a => ToJSON (Set a)
(Ord a, FromJSON a) => FromJSON (Set a)
Ord a => Monoid (Set a)
Default (Set v)
NFData a => NFData (Set a)
(ParseYamlFile a, Ord a) => ParseYamlFile (Set a)

data Map k a

A Map from keys k to values a.

Instances

Typeable2 Map
Functor (Map k)
Foldable (Map k)
Traversable (Map k)
(Eq k, Eq a) => Eq (Map k a)
(Data k, Data a, Ord k) => Data (Map k a)
(Ord k, Ord v) => Ord (Map k v)
(Ord k, Read k, Read e) => Read (Map k e)
(Show k, Show a) => Show (Map k a)
ToJSON v => ToJSON (Map String v)
ToJSON v => ToJSON (Map ByteString v)
ToJSON v => ToJSON (Map ByteString v)
ToJSON v => ToJSON (Map Text v)
ToJSON v => ToJSON (Map Text v)
FromJSON v => FromJSON (Map String v)
FromJSON v => FromJSON (Map ByteString v)
FromJSON v => FromJSON (Map ByteString v)
FromJSON v => FromJSON (Map Text v)
FromJSON v => FromJSON (Map Text v)
Ord k => Monoid (Map k v)
Default (Map k v)
(NFData k, NFData a) => NFData (Map k a)

class (Typeable e, Show e) => Exception e

Any type that you wish to throw or catch as an exception must be an instance of the Exception class. The simplest case is a new exception type directly below the root:

 data MyException = ThisException | ThatException
     deriving (Show, Typeable)

 instance Exception MyException

The default method definitions in the Exception class do what we need in this case. You can now throw and catch ThisException and ThatException as exceptions:

*Main> throw ThisException `catch` \e -> putStrLn ("Caught " ++ show (e :: MyException))
Caught ThisException

In more complicated examples, you may wish to define a whole hierarchy of exceptions:

 ---------------------------------------------------------------------
 -- Make the root exception type for all the exceptions in a compiler

 data SomeCompilerException = forall e . Exception e => SomeCompilerException e
     deriving Typeable

 instance Show SomeCompilerException where
     show (SomeCompilerException e) = show e

 instance Exception SomeCompilerException

 compilerExceptionToException :: Exception e => e -> SomeException
 compilerExceptionToException = toException . SomeCompilerException

 compilerExceptionFromException :: Exception e => SomeException -> Maybe e
 compilerExceptionFromException x = do
     SomeCompilerException a <- fromException x
     cast a

 ---------------------------------------------------------------------
 -- Make a subhierarchy for exceptions in the frontend of the compiler

 data SomeFrontendException = forall e . Exception e => SomeFrontendException e
     deriving Typeable

 instance Show SomeFrontendException where
     show (SomeFrontendException e) = show e

 instance Exception SomeFrontendException where
     toException = compilerExceptionToException
     fromException = compilerExceptionFromException

 frontendExceptionToException :: Exception e => e -> SomeException
 frontendExceptionToException = toException . SomeFrontendException

 frontendExceptionFromException :: Exception e => SomeException -> Maybe e
 frontendExceptionFromException x = do
     SomeFrontendException a <- fromException x
     cast a

 ---------------------------------------------------------------------
 -- Make an exception type for a particular frontend compiler exception

 data MismatchedParentheses = MismatchedParentheses
     deriving (Typeable, Show)

 instance Exception MismatchedParentheses where
     toException   = frontendExceptionToException
     fromException = frontendExceptionFromException

We can now catch a MismatchedParentheses exception as MismatchedParentheses, SomeFrontendException or SomeCompilerException, but not other types, e.g. IOException:

*Main> throw MismatchedParentheses catch e -> putStrLn ("Caught " ++ show (e :: MismatchedParentheses))
Caught MismatchedParentheses
*Main> throw MismatchedParentheses catch e -> putStrLn ("Caught " ++ show (e :: SomeFrontendException))
Caught MismatchedParentheses
*Main> throw MismatchedParentheses catch e -> putStrLn ("Caught " ++ show (e :: SomeCompilerException))
Caught MismatchedParentheses
*Main> throw MismatchedParentheses catch e -> putStrLn ("Caught " ++ show (e :: IOException))
*** Exception: MismatchedParentheses

Instances

Exception Timeout
Exception PatternMatchFail
Exception RecSelError
Exception RecConError
Exception RecUpdError
Exception NoMethodError
Exception NonTermination
Exception NestedAtomically
Exception BlockedIndefinitelyOnMVar
Exception BlockedIndefinitelyOnSTM
Exception Deadlock
Exception AssertionFailed
Exception AsyncException
Exception ArrayException
Exception ExitCode
Exception IOException
Exception SomeException
Exception ErrorCall
Exception ArithException
Exception EventVarietyMismatchException
Exception HttpException
Exception InvalidAccess
Exception FileNameError
Exception TarBombError
Exception PortabilityError
Exception FormatError
Exception UnicodeException
Exception ProcessTrackerException
Exception Void
Exception InvalidRequest
Exception WarpTLSException
Exception ToEventRawException
Exception ParseException
Exception YamlException
Exception KeterException

data SomeException

The SomeException type is the root of the exception type hierarchy. When an exception of type e is thrown, behind the scenes it is encapsulated in a SomeException.

Instances

Show SomeException
Typeable SomeException
Exception SomeException
MonadThrow (Either SomeException)

ProcessCreated FilePath
InvalidBundle FilePath SomeException
ProcessDidNotStart FilePath
ExceptionThrown Text SomeException
RemovingPort Int
UnpackingBundle FilePath
TerminatingApp Text
FinishedReloading Text
TerminatingOldProcess AppId
RemovingOldFolder FilePath
ReceivedInotifyEvent Text
ProcessWaiting FilePath
OtherMessage Text
ErrorStartingBundle Text SomeException
SanityChecksPassed
ReservingHosts AppId (Set Host)
ForgetingReservations AppId (Set Host)
ActivatingApp AppId (Set Host)
DeactivatingApp AppId (Set Host)
ReactivatingApp AppId (Set Host) (Set Host)
WatchedFile Text FilePath

CannotParsePostgres FilePath
ExitCodeFailure FilePath ExitCode
NoPortsAvailable
InvalidConfigFile ParseException
InvalidKeterConfigFile !FilePath !ParseException
CannotReserveHosts !AppId !(Map Host AppId)
FileNotExecutable !FilePath
ExecutableNotFound !FilePath

Show KeterException
Typeable KeterException
Exception KeterException