All Classes and Interfaces
Class
Description
Response Handler which wraps another
Attempt to locate an Access Control List of the given resource for the
current user
Supports AddressDataTypeList objects, and writes them out as a list of
<C:address-data-type content-type="text/vcard" version="3.0"/>
elements
Just adds schedling inbox and outbox to the collection
Placeholder object to represent a node in an annotations hierachy acting as a
collection
A source object (ie your pojo) is considered a collection if it can have
children , ie if there exists at least one @ChildOf or @ChildrenOf method
which has that object as its source type.
Placeholder object to represent a node in an annotations hierarchy acting as a
collection
A source object (ie your POJO) is considered a collection if it can have
children , ie if there exists at least one @ChildOf or @ChildrenOf method
which has that object as its source type.
Common interface for handlers which implement the logic for annotations.
A resource factory which provides access to files in a file system.
Convenience subclass of DigestAuthenticationHandler which just creates
a AppEngineMemcacheNonceProvider as the default nonce provider.
Uses google's memcache implementation to store nonces which are available
across the cluster.
Implementations of this interface are authentication methods for use
with HTTP.
Common sub-interface for inbox and outbox scheduling resources
A read/write source of properties which uses getter/setter style properties
on the resource class.
For response handlers that can be buffered
Generates the cache-control header on the response
Simple abstraction to caching interfaces, represented as Map
Find all calendar objects (ie events) which represent an invitation for the
given user.
Find all calendar objects (ie events) which represent an invitation for the
given user.
Decorator which wraps the underlying display name within a CDATA tag
Provide the underlying DisplayNameFormatter as a constructor argument
A resource factory which looks for resources on the classpath
This is just initial experimental design for solution to already compressed resources problem
Response Handler which wraps another, and compresses content if appropriate
Usually, this will wrap a DefaultResponseHandler, but custom implementations
can be wrapped as well.
Resources may implement this, to allow them to decide dynamically whether
to support particular HTTP methods.
Provides a common interface for servlet and filter configuration
Used to generate error pages from ResponseHandlers.
This wraps a bunch of other authentication handlers, so if any of those
successfully login the user then this will generate a cookie which can be
used subsequently.
Forwards the POST request to the copy method on the wrapped
resource, looking up destination collection and name from the "destination" request parameter
Used for when we want to delegate POST handling to something other then the
usual processForm method.
Represents support for a given property.
Subclasses DispatcherServlet to override logic which filters out requests
for webdav methods such as PROPFIND
I don't know what the spring guys were thinking when they decided to do that,
but at least they made it easy to override.
An implementation of DisplayNameFormatter which just uses the resource
getName() as the display name.
The normal, trivial, implementation of EntityTransport which simply writes
immediately and directly to the Response output stream
Generates the ETag as follows:
- if the resource has a null unique id, returns null
- if the resource has a modified date it's hashcode is appended to the unique id
- the result is returned
The default means of configuring milton's HttpManager.
This default implementation is to allow property access based on the request.
This class performs the main part of PROPFIND processing, which is given a
field request (either named fields or an allprop request) and a target
resource, iterate over that resource and its children (depending on the depth
header) and list a list of PropFindResponse objects.
Simple implmentation which just parses the request body.
Default implementation which just reads the quota properties from
QuotaResource, if the given resource implements it.
Default storage checking mechanism checks to see if the nearest parent
resource implements QuotaResource, and if so uses the available bytes
property from that to determine whether to allow a PUT
Note that there is not always information available giving the size of new content,
and in the case of replacing an existing resource, we might not have that resource's
size.
Supporting functions for the DeleteHandler
Default implementation of DeleteHelper
It will delegate to the resource if it implements
DeletableCollectionResource, otherwise it will walk the collection if its a
CollectionResource, and finally will just call handlerHelper.isLockedOut
otherwise
This interface serves to allow users of milton to implement different
display name strategies.
Represents a means of writing entities to the HTTP response.
Generates ETags, ie entity tags.
Periodically checks a map of Nonce's to remove those which
have expired.
Represents a method of authenticating users using remote sites.
Abstraction for storing and retrieving
A resource factory which provides access to files in a file system.
Interface for a request/response wrapping filter.
Passes the request and response along a series of filters
By default the HttpManager loads a single filter which executes the appropriate
handler for the http method
Additional filters can be added using HttpManager.addFilter
Supports authentication from form parameters.
Represents a directory in a physical file system.
Fake Request object to be used for authorisation.
Attempts to connect to a hazelcast cluster.
Supports HrefList objects, and writes them out as a list of ... elements
Currently readonly, but should support writing
An immutable class to represent an item in a MultiStatus response
The ResponseHandler should handle all responses back to the client.
Milton's main class.
Manages the options for configuring a HttpManager.
Listener interface to hook into the initialization process for HttpManagerBuilder
Abstract class to contain common properties
Just writes an object to the outputstream in JSON notation.
Generates the ETag by just returning the getUniqueId
Handle a caldav connection.
An LDAP principal (ie a user) is simply a contact which can contain other contacts, since
we often allow users to maintain their own private address books as well as
accessing the global contact list
Note that we imply certain meaning to properties defined elsewhere.
NOT TESTED YET!!!!!!
LDAP server, handle LDAP directory requests.
Allows applications to wrap LDAP operations in a transaction
Attempts to connect to a hazelcast cluster.
This decorates a wrapped response handler, and gives it the ability to
generate login pages.
Default implementation which uses some sensible rules about content types
etc
The BeanPropertyResource annotation makes the bean properties on this class
available to milton property resolution.
Implement this to customise how the HttpManager is created in the servlet
IMPORTANT !!!!!!!!!!!
Represents a resource (possibly null) and an absolute path (never null)
Adapts a milton resource factory into an FTP file system, which allows integration
with Apache FTP. ie with this class a milton data source can be accessed by
webdav and FTP simultaneously.
Adapter to between apache FTP's FtpFile interface and milton's Resource interface
This class can wrap any Resource instance and will allow or disallow requests
as appropriate given what methods the resource instance supports - E.g.
Wraps DefaultFtpHandler, adding support for filters
This class is copied from org.apache.ftpserver.impl.DefaultFtpHandler
The only change is that this takes a FtpHandler in its constructor
which is what gets hooked up to Mina.
MiltonServlet is a thin wrapper around HttpManager.
Forwards the POST request to the createCollection method on the wrapped
resource, passin it the "name" request parameter
Windows explorer is VERY picky about the format of its modified date, which
this class supports
Only applies to the getlastmodified field
Forwards the POST request to the move method on the wrapped
resource
Decorator for PropFindRequestFieldParser's.
Write the full content of yuor resource to this outputstream, and it will
write the requested ranges, including multipart boundaries, to the wrapped
outputstream
Parse a string into three components
- username
- domain
- authority
The domain field is to support servers which serve multiple domains, where the user list
is defined per domain.
Represents a Nonce which has been issued and is stored in memory
Provides a source of nonce values to be used in Digest authentication,
and a means to validate nonce values.
Does not do anything
Null safe and pulls the timezone from the request using DataBinder.getTimeZoneForRequest
Mostly copied from DateTimeConverter
Support the OPTIONS http method.
A resource which, as well as being completely replaceable, can have its content
partially replaced. ie individual ranges can be set
While PutHandler will do this for you even if you don't implement this interface,
the approach used might not be efficient.
This just allows the determination of the per method handling class to be
figured out during POST or GET processing, rather then requiring that
determination to be made solely on the basis of the url
A filter to perform authentication before resource location.
Supports PriviledgeList objects, and writes them out as a list of
... elements.
Describes a permission violation.
A type of method handler which does property permission checking.
Helper class for PropertySources.
This class performs the main part of PROPFIND processing, which is given
a field request (either named fields or an allprop request) and a target
resource, iterate over that resource and its children (depending on the
depth header) and list a list of PropFindResponse objects.
Parses the body of a PROPFIND request and returns the requested fields
Applies a proppatch result to a resource
This interface is only really needed to support updating properties via the
old PropPatchableResource.setFields() method.
proxylogconn is a logging version of proxyconn.
proxylogserver is a logging version of proxyserver.
proxyserver listens on given lport, forwards traffic to tport on thost
A collection of utility methods for PutHandler
Will use milton's PUT framework to support file uploads using POST and
multipart encoding
This will save the uploaded files with their given names into the parent
collection resource.
Report with a qualified name so that reports can be implemented from
namespace other than DAV:
Encapsulates access to quota data.
Represents a known report type, is delegated to by the ReportHandler
Assists in determining the logical type of a given resource, for the
purpose of the protocol
4.2.
The following WebDAV properties specified in CalDAV "calendar-access"
[RFC4791] MAY also be defined on scheduling Outbox collections:
CALDAV:supported-calendar-component-set - when present this indicates the
allowed calendar component types for scheduling messages submitted to the
scheduling Outbox collection with the POST method.
Example response:
<?
For any requests which match the mapping path, the request is handled by
simply including a servlet resource at that path
Used to provide access to servlet resources via milton.
Provides access to servlet resources (ie files defined within the folder
which contains WEB-INF) in a milton friendly resource factory
Just uses simple property values to generate error content
Keys on getUniqueID of the locked resource.
A very simple nonce provide that users a map to store issued nonces.
Very basic implementation for development and prototyping
Allows all logged in access
Keys on getUniqueID of the locked resource.
A very simple resource implementation, which simply takes parameters in the
constructor to define the resource, which includes the content
Can be useful for resources defined in by code, where the content is a classpath
item
Has a realm and a map where the keys are user names and the values are
passwords
MiltonServlet is a thin wrapper around HttpManager.
Loads the spring context either from a spring configuration XML file or a
spring @Configuration class.
Specify this class name in your init parameter: resource.factory.factory.class
This will load applicationContext.xml from the classpath and use that to
load the ResourceFactory from bean id: milton.resource.factory
Example web.xml
Used to provide access to static files via Milton
For a full implementation of webdav on a filesystem use the milton-filesysten
project
Used for providing simple readonly access to resources which are files in a
conventional file system.
Implementations will check some aspect of whether or not its allowable
to load some content into the system.
Used as a marker to generate supported locks element in propfind
responses
See SupportedLockValueWriter
Used to transform the requested url prior to resource location
This will contain methods to broadly identify user agents.
Wraps a UserManager from apache FTP to provide a UserManager for
milton
An implementation of ValueWriter will generate xml for some particular property
or type, and be able to parse proppatch textual values into its typed form
Generally ValueWriter's should be symmetrical, in that they can parse what
they generate.
Default list of value writers.
For all webdav extensions to implement.
Defines the methods and properties that make up the webdav protocol.
Provides access to resources exposed by the servlet context.
Used the decorator pattern to add support for .wellknown paths to a custom
resource factory.
Locates a resource for a .well-known/XXX path
Wraps a standard milton securitymanager to implement the UserService required
by FTP.
Lightweight XML generation.