Keter.Types.Common

Documentation

type Appname = Text

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

data Plugin

Constructors

Plugin

Fields

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

type Plugins = [Plugin]

class ToCurrent a where

Used for versioning data types.

Associated Types

type Previous a

Methods

toCurrent :: Previous a -> a

Instances

ToCurrent RedirectConfig

ToCurrent StaticFilesConfig

ToCurrent KeterConfig

ToCurrent BundleConfig

ToCurrent a => ToCurrent (Maybe a)

ToCurrent (WebAppConfig ())

type Port = Int

A port for an individual app to listen on.

type Host = CI Text

A virtual host we want to serve content from.

type HostBS = CI ByteString

getAppname :: FilePath -> Text

data LogMessage

Constructors

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

Instances

Show LogMessage

data KeterException

Constructors

CannotParsePostgres FilePath

ExitCodeFailure FilePath ExitCode

NoPortsAvailable

InvalidConfigFile ParseException

InvalidKeterConfigFile !FilePath !ParseException

CannotReserveHosts !AppId !(Map Host AppId)

FileNotExecutable !FilePath

ExecutableNotFound !FilePath

Instances

Show KeterException

Exception KeterException

Typeable * KeterException

logEx :: Q Exp

data AppId

Constructors

AIBuiltin

AINamed !Appname

Instances

Eq AppId

Ord AppId

Show AppId

type FilePath = String

File and directory names are values of type String, whose precise meaning is operating system dependent. Files can be opened, yielding a handle which can then be used to operate on the contents of that file.

data Text :: *

A space efficient, packed, unboxed Unicode text type.

Instances

IsList Text

Eq Text

Data Text

This instance preserves data abstraction at the cost of inefficiency. We omit reflection services for the sake of data abstraction.

This instance was created by copying the updated behavior of Data.Set.Set and Data.Map.Map. If you feel a mistake has been made, please feel free to submit improvements.

The original discussion is archived here: could we get a Data instance for Data.Text.Text?

The followup discussion that changed the behavior of Set and Map is archived here: Proposal: Allow gunfold for Data.Map, ...

Ord Text

Read Text

Show Text

IsString Text

ToJSON Text

FromJSON Text

Chunk Text

Monoid Text

Binary Text

FoldCase Text

NFData Text

Hashable Text

Semigroup Text

Typeable * 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)

type State Text = Buffer

type ChunkElem Text = Char

type Item Text = Char

data ByteString :: *

A space-efficient representation of a Word8 vector, supporting many efficient operations.

A ByteString contains 8-bit bytes, or by using the operations from Data.ByteString.Char8 it can be interpreted as containing 8-bit characters.

Instances

Eq ByteString

Data ByteString

Ord ByteString

Read ByteString

Show ByteString

IsString ByteString

Chunk ByteString

Monoid ByteString

FoldCase ByteString

Note that foldCase on ByteStrings is only guaranteed to be correct for ISO-8859-1 encoded strings!

NFData ByteString

Hashable ByteString

Extract ByteString

Semigroup ByteString

Typeable * ByteString

RegexLike Regex ByteString

RegexContext Regex ByteString ByteString

RegexMaker Regex CompOption ExecOption ByteString

(~) * a ByteString => IsString (Parser a)

type State ByteString = Buffer

type ChunkElem ByteString = Word8

data Set a :: * -> *

A set of values a.

Instances

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)

Ord a => Semigroup (Set a)

(ParseYamlFile a, Ord a) => ParseYamlFile (Set a)

Typeable (* -> *) Set

data Map k a :: * -> * -> *

A Map from keys k to values a.

Instances

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 Text v)

ToJSON v => ToJSON (Map Text v)

FromJSON v => FromJSON (Map String 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)

Ord k => Semigroup (Map k v)

Typeable (* -> * -> *) Map

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 SomeAsyncException

Exception AsyncException

Exception ArrayException

Exception ExitCode

Exception IOException

Exception ErrorCall

Exception ArithException

Exception SomeException

Exception EventVarietyMismatchException

Exception HttpException

Exception InvalidAccess

Exception FileNameError

Exception TarBombError

Exception PortabilityError

Exception FormatError

Exception UnicodeException

Exception Void

Exception InvalidRequest

Exception TimeoutThread

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

Exception SomeException

Typeable * SomeException