public Task Invoke(IDictionary<string, object> environment)
{
if (!environment.Get<string>(OwinConstants.RequestMethodKey).EqualsIgnoreCase("GET"))
{
return _inner(environment);
}
var originalOutput = environment.Get<Stream>(OwinConstants.ResponseBodyKey);
var recordedStream = new MemoryStream();
environment.Set(OwinConstants.ResponseBodyKey, recordedStream);
return _inner(environment).ContinueWith(t => {
recordedStream.Position = 0;
environment[OwinConstants.ResponseBodyKey] = originalOutput;
var response = new OwinHttpResponse(environment);
if (IsGetHtmlRequest(environment) && response.StatusCode < 500)
{
injectContent(environment, recordedStream, response);
}
else
{
response.StreamContents(recordedStream);
}
});
}
/// <summary>
///
/// </summary>
/// <param name="environment">OWIN environment dictionary which stores state information about the request, response and relevant server state.</param>
/// <returns></returns>
public Task Invoke(IDictionary<string, object> environment)
{
if (environment == null)
{
throw new ArgumentNullException("environment");
}
// No IPrincipal
if (environment.Get<IPrincipal>(Constants.ServerUserKey) == null)
{
environment[Constants.ResponseStatusCodeKey] = 401;
return GetCompletedTask();
}
// Anonymous IPrincipal
var winPrincipal = environment.Get<IPrincipal>(Constants.ServerUserKey) as WindowsPrincipal;
if (winPrincipal != null)
{
var winIdentity = winPrincipal.Identity as WindowsIdentity;
if (winIdentity != null && winIdentity.IsAnonymous)
{
environment[Constants.ResponseStatusCodeKey] = 401;
return GetCompletedTask();
}
}
return _nextApp(environment);
}
void IConstructable.Construct(IDictionary<string, string> param)
{
if (param.Get("source", null) != null)
Source = param.Get("source", null);
else
Source = File.Exists(param["sourceRef"]) ? File.ReadAllText(param["sourceRef"]) : "";
}
private void PrivateMessageCommand(IDictionary<string, object> command)
{
var sender = command.Get(Constants.Arguments.Character);
if (!CharacterManager.IsOnList(sender, ListKind.Ignored))
{
if (ChatModel.CurrentPms.FirstByIdOrNull(sender) == null)
channels.AddChannel(ChannelType.PrivateMessage, sender);
channels.AddMessage(command.Get(Constants.Arguments.Message), sender, sender);
var temp = ChatModel.CurrentPms.FirstByIdOrNull(sender);
if (temp == null)
return;
temp.TypingStatus = TypingStatus.Clear; // webclient assumption
}
else
{
ChatConnection.SendMessage(
new Dictionary<string, object>
{
{Constants.Arguments.Action, Constants.Arguments.ActionNotify},
{Constants.Arguments.Character, sender},
{Constants.Arguments.Type, Constants.ClientCommands.UserIgnore}
});
}
}
private void LeaveChannelCommand(IDictionary<string, object> command)
{
var channelId = command.Get(Constants.Arguments.Channel);
var characterName = command.Get(Constants.Arguments.Character);
var channel = ChatModel.CurrentChannels.FirstByIdOrNull(channelId);
if (ChatModel.CurrentCharacter.NameEquals(characterName))
{
if (channel != null)
channels.RemoveChannel(channelId, false, true);
return;
}
if (channel == null)
return;
var ignoreUpdate = false;
if (command.ContainsKey("ignoreUpdate"))
ignoreUpdate = (bool) command["ignoreUpdate"];
if (!channel.CharacterManager.SignOff(characterName) || ignoreUpdate) return;
var updateArgs = new JoinLeaveEventArgs
{
Joined = false,
TargetChannel = channel.Title,
TargetChannelId = channel.Id
};
Events.NewCharacterUpdate(CharacterManager.Find(characterName), updateArgs);
}
public Task Invoke(IDictionary<string, object> env)
{
var opaqueUpgrade = env.Get<OpaqueUpgrade>("opaque.Upgrade");
var webSocketAccept = env.Get<WebSocketAccept>(Constants.WebSocketAcceptKey);
if (opaqueUpgrade != null
&& webSocketAccept == null
&& IsWebSocketRequest(env))
{
// Add websocket support
env[Constants.WebSocketAcceptKey] = new WebSocketAccept(
(options, callback) =>
{
if (callback == null)
{
throw new ArgumentNullException("callback");
}
env[Constants.ResponseStatusCodeKey] = 101;
SetWebSocketResponseHeaders(env, options);
opaqueUpgrade(options,
opaqueEnv =>
{
var webSocket = new WebSocketLayer(opaqueEnv);
return callback(webSocket.Environment)
.Then(() => webSocket.CleanupAsync());
});
});
}
return _next(env);
}
private void OnPivateMessageSendRequested(IDictionary<string, object> command)
{
channels.AddMessage(
command.Get(Constants.Arguments.Message),
command.Get("recipient"),
Constants.Arguments.ThisCharacter);
connection.SendMessage(command);
}
public void Map(IDictionary<string, object> document, Emitter emitter)
{
bool vacant = (bool)document.Get("vacant");
string name = (string)document.Get("name");
if (vacant && name != null)
{
emitter.Emit(name, vacant);
}
}
public RedisLiveConnection(IDictionary<string, string> settings)
{
if (!settings.TryGet("host", out _Host))
{
throw new Exception("Redis host is required");
}
_Port = settings.Get("port", 6379);
_Timeout = settings.Get("timeout", 2000);
}
public OwinRequestData(RouteData routeData, IDictionary<string, object> environment, ICurrentHttpRequest currentRequest)
{
AddValues(new RouteDataValues(routeData));
AddValues(Querystring, new NamedKeyValues(HttpUtility.ParseQueryString(environment.Get<string>(OwinConstants.RequestQueryStringKey))));
AddValues(FormPost, new NamedKeyValues(environment.Get<NameValueCollection>(OwinConstants.RequestFormKey)));
AddValues(new CookieValueSource(new Cookies(currentRequest)));
AddValues(new HeaderValueSource(currentRequest));
}
private void OnLrpRequested(IDictionary<string, object> command)
{
channels.AddMessage(
command.Get(Constants.Arguments.Message),
command.Get(Constants.Arguments.Channel),
Constants.Arguments.ThisCharacter,
MessageType.Ad);
connection.SendMessage(command);
}
private void InviteCommand(IDictionary<string, object> command)
{
var sender = command.Get(Constants.Arguments.Sender);
var id = command.Get(Constants.Arguments.Name);
var title = command.Get(Constants.Arguments.Title);
var args = new ChannelInviteEventArgs {Inviter = sender};
Events.NewChannelUpdate(ChatModel.FindChannel(id, title), args);
}
public static IDisposable Create(Func<IDictionary<string, object>, Task> app, IDictionary<string, object> properties)
{
if (app == null)
{
throw new ArgumentNullException("app");
}
if (properties == null)
{
throw new ArgumentNullException("properties");
}
var capabilities = properties.Get<IDictionary<string, object>>(OwinKeys.ServerCapabilitiesKey)
?? new Dictionary<string, object>();
var addresses = properties.Get<IList<IDictionary<string, object>>>("host.Addresses")
?? new List<IDictionary<string, object>>();
var servers = new List<INowinServer>();
var endpoints = new List<IPEndPoint>();
foreach (var address in addresses)
{
var builder = ServerBuilder.New().SetOwinApp(app);
int port;
if (!int.TryParse(address.Get<string>("port"), out port)) throw new ArgumentException("port must be number from 0 to 65535");
builder.SetPort(port);
builder.SetOwinCapabilities(capabilities);
var certificate = address.Get<X509Certificate>("certificate");
if (certificate != null)
builder.SetCertificate(certificate);
servers.Add(builder.Build());
endpoints.Add(new IPEndPoint(IPAddress.Loopback,port));
}
var disposer = new Disposer(servers.Cast<IDisposable>().ToArray());
try
{
foreach (var nowinServer in servers)
{
nowinServer.Start();
}
// This is workaround to Windows Server 2012 issue by calling ReadLine after AcceptAsync, by making one bogus connection this problem goes away
foreach (var ipEndPoint in endpoints)
{
var socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.IP);
socket.Connect(ipEndPoint);
socket.Close();
}
}
catch (Exception)
{
disposer.Dispose();
throw;
}
return disposer;
}
private void OnTemporaryInterestedRequested(IDictionary<string, object> command)
{
var character = command.Get(Constants.Arguments.Character).ToLower().Trim();
var add = command.Get(Constants.Arguments.Type) == "tempinteresting";
characterManager.Add(
character,
add ? ListKind.Interested : ListKind.NotInterested,
true);
}
public Task Invoke(IDictionary<string, object> env)
{
IList<string> warnings = new List<string>();
if (!TryValidateCall(env, warnings))
{
return TaskHelpers.Completed();
}
Stream originalStream = env.Get<Stream>("owin.ResponseBody");
TriggerStream triggerStream = new TriggerStream(originalStream);
env["owin.ResponseBody"] = triggerStream;
// Validate response headers and values on first write.
bool responseValidated = false;
Action responseValidation = () =>
{
if (responseValidated)
{
return;
}
responseValidated = true;
if (!TryValidateResult(env, warnings))
{
return;
}
if (warnings.Count > 0)
{
var headers = env.Get<IDictionary<string, string[]>>(OwinConstants.ResponseHeaders);
headers["X-OwinValidatorWarning"] = warnings.ToArray();
}
};
triggerStream.OnFirstWrite = responseValidation;
try
{
return nextApp(env)
// Run response validation explicitly in case there was no response data written.
.Then(responseValidation)
.Catch(errorInfo =>
{
SetFatalResult(env, "6.1", "An asynchronous exception was thrown from the AppFunc: <br>"
+ errorInfo.Exception.ToString().Replace(Environment.NewLine, "<br>"));
return errorInfo.Handled();
});
}
catch (Exception ex)
{
SetFatalResult(env, "6.1", "A synchronous exception was thrown from the AppFunc: <br>"
+ ex.ToString().Replace(Environment.NewLine, "<br>"));
return TaskHelpers.Completed();
}
}
public void Map(IDictionary<string, object> document, Emitter emitter)
{
if (Profile.DocType.Equals(document.Get("type")))
{
if (ignoreUserId == null || (ignoreUserId != null && !ignoreUserId.Equals(document
.Get("user_id"))))
{
emitter.Emit(document.Get("name"), document);
}
}
}
public WebSocketLayer(IDictionary<string, object> opaqueEnv)
{
_environment = opaqueEnv;
_environment["websocket.SendAsync"] = new WebSocketSendAsync(SendAsync);
_environment["websocket.ReceiveAsync"] = new WebSocketReceiveAsync(ReceiveAsync);
_environment["websocket.CloseAsync"] = new WebSocketCloseAsync(CloseAsync);
_environment["websocket.CallCancelled"] = _environment["opaque.CallCancelled"];
_environment["websocket.Version"] = "1.0";
_incoming = _environment.Get<Stream>("opaque.Incoming");
_outgoing = _environment.Get<Stream>("opaque.Outgoing");
}
private void RoomModeChangedCommand(IDictionary<string, object> command)
{
var channelId = command.Get(Constants.Arguments.Channel);
var mode = command.Get(Constants.Arguments.Mode);
var newMode = mode.ToEnum<ChannelMode>();
var channel = ChatModel.CurrentChannels.FirstByIdOrNull(channelId);
if (channel == null)
return;
channel.Mode = newMode;
Events.NewChannelUpdate(channel, new ChannelModeUpdateEventArgs {NewMode = newMode});
}
public Task Invoke(IDictionary<string, object> environment)
{
var path = environment.Get<string>(OwinConstants.RequestPath);
if (path == null || !path.StartsWith(_path, StringComparison.OrdinalIgnoreCase))
{
return _next(environment);
}
var pathBase = environment.Get<string>(OwinConstants.RequestPathBase);
var dispatcher = new HubDispatcher(pathBase + _path, _enableJavaScriptProxies);
var handler = new CallHandler(_resolver, dispatcher);
return handler.Invoke(environment);
}
public Task Invoke(IDictionary<string, object> env)
{
string pathInfo = env.Get<string>(OwinConstants.RequestPath);
if (pathInfo.StartsWith("/"))
{
pathInfo = pathInfo.Substring(1);
}
if (pathInfo.Contains(".."))
{
return Fail(Forbidden, "Forbidden").Invoke(env);
}
string path = Path.Combine(root ?? string.Empty, pathInfo);
if (!File.Exists(path))
{
return Fail(NotFound, "File not found: " + pathInfo).Invoke(env);
}
try
{
return Serve(env, path);
}
catch (UnauthorizedAccessException)
{
return Fail(Forbidden, "Forbidden").Invoke(env);
}
}
public Task Invoke(IDictionary<string, object> env)
{
// The TraceSource is assumed to be the same across all requests.
traceSource = traceSource ?? env.Get<TraceSource>("host.TraceSource");
if (traceSource == null)
{
return nextApp(env);
}
try
{
TraceCall(env);
return nextApp(env).Then(() =>
{
TraceResult(env);
})
.Catch(errorInfo =>
{
TraceException(errorInfo.Exception, "asynchronously");
return errorInfo.Throw();
});
}
catch (Exception ex)
{
TraceException(ex, "synchronously");
throw;
}
}
public CausationContext(IDictionary<string, object> environment, string key, string newValue)
{
_environment = environment;
_key = key;
_oldValue = environment.Get<string>(key);
environment[key] = newValue;
}
private void OnPrivRequested(IDictionary<string, object> command)
{
var characterName = command.Get(Constants.Arguments.Character);
if (cm.CurrentCharacter.NameEquals(characterName))
{
events.NewError("Hmmm... talking to yourself?");
return;
}
var isExact = characterName.StartsWith("\"") && characterName.EndsWith("\"");
ICharacter guess = null;
if (isExact)
{
characterName = characterName.Substring(1, characterName.Length - 2);
}
else
{
guess = characterManager.SortedCharacters.OrderBy(x => x.Name)
.Where(x => !x.NameEquals(cm.CurrentCharacter.Name))
.FirstOrDefault(c => c.Name.StartsWith(characterName, true, null));
}
channels.JoinChannel(ChannelType.PrivateMessage, guess == null ? characterName : guess.Name);
}
public AttributesFacetHandler(string name, string indexFieldName, TermListFactory termListFactory, Term sizePayloadTerm, IDictionary<string, string> facetProps)
: base(name, indexFieldName, sizePayloadTerm, termListFactory, new string[0])
{
if (facetProps.ContainsKey(SEPARATOR_PROP_NAME))
{
this.separator = Narrow(facetProps.Get(SEPARATOR_PROP_NAME))[0];
}
else
{
this.separator = DEFAULT_SEPARATOR;
}
if (facetProps.ContainsKey(MAX_FACETS_PER_KEY_PROP_NAME))
{
this.numFacetsPerKey = int.Parse(Narrow(facetProps.Get(MAX_FACETS_PER_KEY_PROP_NAME)));
}
}
private void ChannelDescriptionCommand(IDictionary<string, object> command)
{
lock (chatStateLocker)
{
var channel = FindChannel(command);
var description = command.Get("description");
if (channel == null)
{
RequeueCommand(command);
return;
}
var isInitializer = string.IsNullOrWhiteSpace(channel.Description);
if (string.Equals(channel.Description, description, StringComparison.Ordinal))
return;
channel.Description = WebUtility.HtmlDecode(WebUtility.HtmlDecode(description));
if (isInitializer)
return;
var args = new ChannelDescriptionChangedEventArgs();
Events.NewChannelUpdate(channel, args);
}
}
private static void DetectWebSocketSupport(IDictionary<string, object> properties)
{
// There is no explicit API to detect server side websockets, just check for v4.5 / Win8.
// Per request we can provide actual verification.
if (Environment.OSVersion.Version >= new Version(6, 2))
{
var capabilities = properties.Get<CapabilitiesDictionary>(Constants.ServerCapabilitiesKey);
capabilities[Constants.WebSocketVersionKey] = Constants.WebSocketVersion;
}
else
{
var loggerFactory = properties.Get<LoggerFactoryFunc>(Constants.ServerLoggerFactoryKey);
LoggerFunc logger = LogHelper.CreateLogger(loggerFactory, typeof(OwinServerFactory));
LogHelper.LogInfo(logger, "No WebSocket support detected, Windows 8 or later is required.");
}
}
public static IDisposable Create(AppFunc app, IDictionary<string, object> properties)
{
if (app == null)
{
throw new ArgumentNullException("app");
}
if (properties == null)
{
throw new ArgumentNullException("properties");
}
// Retrieve the instances created in Initialize
OwinHttpListener wrapper = properties.Get<OwinHttpListener>(typeof(OwinHttpListener).FullName)
?? new OwinHttpListener();
System.Net.HttpListener listener = properties.Get<System.Net.HttpListener>(typeof(System.Net.HttpListener).FullName)
?? new System.Net.HttpListener();
AddressList addresses = properties.Get<AddressList>(Constants.HostAddressesKey)
?? new List<IDictionary<string, object>>();
CapabilitiesDictionary capabilities =
properties.Get<CapabilitiesDictionary>(Constants.ServerCapabilitiesKey)
?? new Dictionary<string, object>();
var loggerFactory = properties.Get<LoggerFactoryFunc>(Constants.ServerLoggerFactoryKey);
wrapper.Start(listener, app, addresses, capabilities, loggerFactory);
return wrapper;
}
private void ChannelInitializedCommand(IDictionary<string, object> command)
{
lock (chatStateLocker)
{
var channel = FindChannel(command);
var mode = command.Get(Constants.Arguments.Mode).ToEnum<ChannelMode>();
if (channel == null)
{
RequeueCommand(command);
return;
}
channel.Mode = mode;
var users = (JsonArray) command[Constants.Arguments.MultipleUsers];
foreach (IDictionary<string, object> character in users)
{
var name = character.Get(Constants.Arguments.Identity);
if (string.IsNullOrWhiteSpace(name))
continue;
channel.CharacterManager.SignOn(CharacterManager.Find(name));
}
}
}
private void SetNewOwnerCommand(IDictionary<string, object> command)
{
var character = command.Get(Constants.Arguments.Character);
var channelId = command.Get(Constants.Arguments.Channel);
var channel = ChatModel.CurrentChannels.FirstByIdOrNull(channelId);
if (channel == null) return;
var mods = channel.CharacterManager.GetNames(ListKind.Moderator, false).ToList();
mods[0] = character;
channel.CharacterManager.Set(mods, ListKind.Moderator);
var update = new ChannelUpdateModel(channel, new ChannelOwnerChangedEventArgs {NewOwner = character});
Events.NewUpdate(update);
}
public void Read(IDictionary<string, object> environment)
{
var form = new NameValueCollection();
environment.Add(OwinConstants.RequestFormKey, form);
var mediaType = environment.Get<string>(OwinConstants.MediaTypeKey);
if (mediaType != MimeType.HttpFormMimetype && mediaType != MimeType.MultipartMimetype) return;
string formValue;
var body = environment.Get<Stream>(OwinConstants.RequestBodyKey);
using (var reader = new StreamReader(body))
{
formValue = reader.ReadToEnd();
}
form.Add(HttpUtility.ParseQueryString(formValue));
}
public override Type GetPropertyTypeMap(
IDictionary<string, object> optionalMapPropTypes,
BeanEventTypeFactory beanEventTypeFactory)
{
// The simple, none-dynamic property needs a definition of the map contents else no property
var def = optionalMapPropTypes?.Get(PropertyNameAtomic);
if (def == null) {
return null;
}
if (def is Type) {
return (Type) def;
}
if (def is IDictionary<string, object>) {
return typeof(IDictionary<string, object>);
}
if (def is TypeBeanOrUnderlying) {
var eventType = ((TypeBeanOrUnderlying) def).EventType;
return eventType.UnderlyingType;
}
if (def is TypeBeanOrUnderlying[]) {
var eventType = ((TypeBeanOrUnderlying[]) def)[0].EventType;
return TypeHelper.GetArrayType(eventType.UnderlyingType);
}
if (def is EventType) {
var eventType = (EventType) def;
return eventType.UnderlyingType;
}
if (def is EventType[]) {
var eventType = (EventType[]) def;
return TypeHelper.GetArrayType(eventType[0].UnderlyingType);
}
var message = "Nestable map type configuration encountered an unexpected value type of '" +
def.GetType() +
"' for property '" +
PropertyNameAtomic +
"', expected Map or Class";
throw new PropertyAccessException(message);
}
public override MapEventPropertyGetter GetGetterMap(
IDictionary<string, object> optionalMapPropTypes,
EventBeanTypedEventFactory eventBeanTypedEventFactory,
BeanEventTypeFactory beanEventTypeFactory)
{
// The simple, none-dynamic property needs a definition of the map contents else no property
var def = optionalMapPropTypes?.Get(PropertyNameAtomic);
if (def == null) {
return null;
}
if (def is EventType) {
return new MapEventBeanPropertyGetter(PropertyNameAtomic, ((EventType) def).UnderlyingType);
}
return new MapPropertyGetterDefaultNoFragment(PropertyNameAtomic, eventBeanTypedEventFactory);
}
private void UploadChanges(IList <RevisionInternal> changes, IDictionary <string, object> revsDiffResults)
{
// Go through the list of local changes again, selecting the ones the destination server
// said were missing and mapping them to a JSON dictionary in the form _bulk_docs wants:
var docsToSend = new List <object> ();
var revsToSend = new RevisionList();
IDictionary <string, object> revResults = null;
foreach (var rev in changes)
{
// Is this revision in the server's 'missing' list?
if (revsDiffResults != null)
{
revResults = revsDiffResults.Get(rev.DocID).AsDictionary <string, object>();
if (revResults == null)
{
continue;
}
var revs = revResults.Get("missing").AsList <string>();
if (revs == null || !revs.Any(id => id.Equals(rev.RevID.ToString())))
{
RemovePending(rev);
continue;
}
}
IDictionary <string, object> properties = null;
RevisionInternal loadedRev;
try {
loadedRev = LocalDatabase.LoadRevisionBody(rev);
if (loadedRev == null)
{
throw Misc.CreateExceptionAndLog(Log.To.Sync, StatusCode.NotFound, TAG,
"Unable to load revision body");
}
properties = new Dictionary <string, object>(rev.GetProperties());
} catch (Exception e1) {
Log.To.Sync.E(TAG, String.Format("Couldn't get local contents of {0}, marking revision failed",
rev), e1);
RevisionFailed();
continue;
}
if (properties.GetCast <bool> ("_removed"))
{
RemovePending(rev);
continue;
}
var populatedRev = TransformRevision(loadedRev);
var backTo = revResults?.Get("possible_ancestors")?.AsList <RevisionID>();
try {
var history = LocalDatabase.GetRevisionHistory(populatedRev, backTo);
if (history == null)
{
throw Misc.CreateExceptionAndLog(Log.To.Sync, StatusCode.DbError, TAG,
"Unable to load revision history");
}
properties["_revisions"] = TreeRevisionID.MakeRevisionHistoryDict(history);
populatedRev.SetPropertyForKey("_revisions", properties["_revisions"]);
} catch (Exception e1) {
Log.To.Sync.E(TAG, "Error getting revision history, marking revision failed", e1);
RevisionFailed();
continue;
}
// Strip any attachments already known to the target db:
if (properties.Get("_attachments") != null)
{
// Look for the latest common ancestor and stuf out older attachments:
var minRevPos = FindCommonAncestor(populatedRev, backTo);
try {
LocalDatabase.ExpandAttachments(populatedRev, minRevPos + 1, !_dontSendMultipart, false);
} catch (Exception ex) {
Log.To.Sync.E(TAG, "Error expanding attachments, marking revision failed", ex);
RevisionFailed();
continue;
}
properties = populatedRev.GetProperties();
if (!_dontSendMultipart && UploadMultipartRevision(populatedRev))
{
continue;
}
}
if (properties == null || !properties.ContainsKey("_id"))
{
throw Misc.CreateExceptionAndLog(Log.To.Sync, StatusCode.BadParam, TAG,
"properties must contain a document _id");
}
// Add the _revisions list:
revsToSend.Add(rev);
//now add it to the docs to send
docsToSend.Add(properties);
}
UploadBulkDocs(docsToSend, revsToSend);
}
public override string DeploymentGetStage(string deploymentId)
{
return(_deploymentIdStages?.Get(deploymentId));
}
public AttachmentInternal(string name, IDictionary <string, object> info)
: this(name, info.GetCast <string>("content_type"))
{
Length = info.GetCast <long>("length");
EncodedLength = info.GetCast <long>("encoded_length");
_digest = info.GetCast <string>("digest");
if (_digest != null)
{
BlobKey = new BlobKey(_digest);
}
string encodingString = info.GetCast <string>("encoding");
if (encodingString != null)
{
if (encodingString.Equals("gzip"))
{
Encoding = AttachmentEncoding.GZIP;
}
else
{
throw Misc.CreateExceptionAndLog(Log.To.Database, StatusCode.BadEncoding, TAG,
"Invalid encoding type ({0}) in ctor", encodingString);
}
}
var data = info.Get("data");
if (data != null)
{
// If there's inline attachment data, decode and store it:
if (data is string)
{
_data = Convert.FromBase64String((string)data);
}
else
{
_data = data as IEnumerable <byte>;
}
if (_data == null)
{
throw Misc.CreateExceptionAndLog(Log.To.Database, StatusCode.BadEncoding, TAG,
"Invalid data type ({0}) in ctor", data.GetType().Name);
}
SetPossiblyEncodedLength(_data.LongCount());
}
else if (info.GetCast <bool>("stub", false))
{
// This item is just a stub; validate and skip it
if (info.ContainsKey("revpos"))
{
var revPos = info.GetCast("revpos", -1); // PouchDB has a bug that generates "revpos":0; allow this (#627)
if (revPos < 0)
{
throw Misc.CreateExceptionAndLog(Log.To.Database, StatusCode.BadAttachment, TAG,
"Invalid revpos ({0}) in ctor", revPos);
}
RevPos = revPos;
}
}
else if (info.GetCast <bool>("follows", false))
{
// I can't handle this myself; my caller will look it up from the digest
if (Digest == null)
{
throw Misc.CreateExceptionAndLog(Log.To.Database, StatusCode.BadAttachment, TAG,
"follows is true, but the attachment digest is null in ctor");
}
if (info.ContainsKey("revpos"))
{
var revPos = info.GetCast("revpos", -1); // PouchDB has a bug that generates "revpos":0; allow this (#627)
if (revPos < 0)
{
throw Misc.CreateExceptionAndLog(Log.To.Database, StatusCode.BadAttachment, TAG,
"Invalid revpos ({0}) in ctor", revPos);
}
RevPos = revPos;
}
}
else
{
throw Misc.CreateExceptionAndLog(Log.To.Database, StatusCode.BadAttachment, TAG,
"Neither data nor stub nor follows was specified on the attachment data");
}
}
internal static IDictionary <string, object> CblAttachments(this IDictionary <string, object> dict)
{
return(dict?.Get("_attachments").AsDictionary <string, object>());
}
public virtual PdfDictionary BuildTree()
{
int?[] numbers = new int?[items.Count];
numbers = items.Keys.ToArray(numbers);
iText.IO.Util.JavaUtil.Sort(numbers);
if (numbers.Length <= NODE_SIZE)
{
PdfDictionary dic = new PdfDictionary();
PdfArray ar = new PdfArray();
for (int k = 0; k < numbers.Length; ++k)
{
ar.Add(new PdfNumber((int)numbers[k]));
ar.Add(items.Get(numbers[k]));
}
dic.Put(PdfName.Nums, ar);
return(dic);
}
int skip = NODE_SIZE;
PdfDictionary[] kids = new PdfDictionary[(numbers.Length + NODE_SIZE - 1) / NODE_SIZE];
for (int i = 0; i < kids.Length; ++i)
{
int offset = i * NODE_SIZE;
int end = Math.Min(offset + NODE_SIZE, numbers.Length);
PdfDictionary dic = new PdfDictionary();
PdfArray arr = new PdfArray();
arr.Add(new PdfNumber((int)numbers[offset]));
arr.Add(new PdfNumber((int)numbers[end - 1]));
dic.Put(PdfName.Limits, arr);
arr = new PdfArray();
for (; offset < end; ++offset)
{
arr.Add(new PdfNumber((int)numbers[offset]));
arr.Add(items.Get(numbers[offset]));
}
dic.Put(PdfName.Nums, arr);
dic.MakeIndirect(catalog.GetDocument());
kids[i] = dic;
}
int top = kids.Length;
while (true)
{
if (top <= NODE_SIZE)
{
PdfArray arr = new PdfArray();
for (int k = 0; k < top; ++k)
{
arr.Add(kids[k]);
}
PdfDictionary dic = new PdfDictionary();
dic.Put(PdfName.Kids, arr);
return(dic);
}
skip *= NODE_SIZE;
int tt = (numbers.Length + skip - 1) / skip;
for (int k_1 = 0; k_1 < tt; ++k_1)
{
int offset = k_1 * NODE_SIZE;
int end = Math.Min(offset + NODE_SIZE, top);
PdfDictionary dic = ((PdfDictionary) new PdfDictionary().MakeIndirect(catalog.GetDocument()));
PdfArray arr = new PdfArray();
arr.Add(new PdfNumber((int)numbers[k_1 * skip]));
arr.Add(new PdfNumber((int)numbers[Math.Min((k_1 + 1) * skip, numbers.Length) - 1]));
dic.Put(PdfName.Limits, arr);
arr = new PdfArray();
for (; offset < end; ++offset)
{
arr.Add(kids[offset]);
}
dic.Put(PdfName.Kids, arr);
kids[k_1] = dic;
}
top = tt;
}
}
public Ref GetRef(string name)
{
return(advertisedRefs.Get(name));
}
public static String UnicodeToName(int num)
{
return(unicode2names.Get(num));
}
/// <summary>
/// NOTE: Code-generation-invoked method, method name and parameter order matters
/// </summary>
/// <param name="map">map</param>
/// <param name="key">key</param>
/// <returns>value</returns>
public static object GetAvroMappedValueWNullCheck(
IDictionary<string, object> map,
string key)
{
return map?.Get(key);
}
/// <exception cref="System.IO.IOException"/>
private void OutputDss(PdfDictionary dss, PdfDictionary vrim, PdfArray ocsps, PdfArray crls, PdfArray certs
)
{
PdfCatalog catalog = document.GetCatalog();
catalog.AddDeveloperExtension(PdfDeveloperExtension.ESIC_1_7_EXTENSIONLEVEL5);
catalog.SetModified();
foreach (PdfName vkey in validated.Keys)
{
PdfArray ocsp = new PdfArray();
PdfArray crl = new PdfArray();
PdfArray cert = new PdfArray();
PdfDictionary vri = new PdfDictionary();
foreach (byte[] b in validated.Get(vkey).crls)
{
PdfStream ps = new PdfStream(b);
ps.SetCompressionLevel(CompressionConstants.DEFAULT_COMPRESSION);
ps.MakeIndirect(document);
crl.Add(ps);
crls.Add(ps);
}
foreach (byte[] b_1 in validated.Get(vkey).ocsps)
{
PdfStream ps = new PdfStream(b_1);
ps.SetCompressionLevel(CompressionConstants.DEFAULT_COMPRESSION);
ocsp.Add(ps);
ocsps.Add(ps);
}
foreach (byte[] b_2 in validated.Get(vkey).certs)
{
PdfStream ps = new PdfStream(b_2);
ps.SetCompressionLevel(CompressionConstants.DEFAULT_COMPRESSION);
ps.MakeIndirect(document);
cert.Add(ps);
certs.Add(ps);
}
if (ocsp.Size() > 0)
{
ocsp.MakeIndirect(document);
vri.Put(PdfName.OCSP, ocsp);
}
if (crl.Size() > 0)
{
crl.MakeIndirect(document);
vri.Put(PdfName.CRL, crl);
}
if (cert.Size() > 0)
{
cert.MakeIndirect(document);
vri.Put(PdfName.Cert, cert);
}
vri.MakeIndirect(document);
vrim.Put(vkey, vri);
}
vrim.MakeIndirect(document);
dss.Put(PdfName.VRI, vrim);
if (ocsps.Size() > 0)
{
ocsps.MakeIndirect(document);
dss.Put(PdfName.OCSPs, ocsps);
}
if (crls.Size() > 0)
{
crls.MakeIndirect(document);
dss.Put(PdfName.CRLs, crls);
}
if (certs.Size() > 0)
{
certs.MakeIndirect(document);
dss.Put(PdfName.Certs, certs);
}
dss.MakeIndirect(document);
catalog.Put(PdfName.DSS, dss);
}
/// =========================================================================================================================================================
/// <summary>
/// Gets a value from the given dictionary
/// </summary>
/// <typeparam name="K">The type parameter for the keys of the dictionary</typeparam>
/// <typeparam name="V">The type parameter for the values of the dictionary</typeparam>
/// <param name="dictionary">The dictionary to get the value from</param>
/// <param name="key">The key of the value that should be returned from the dictionary</param>
/// <returns>The value of the given key or the default value of the type parameter for the values</returns>
/// =========================================================================================================================================================
public static V Get <K, V>(this IDictionary <K, V> dictionary, K key)
{
return(dictionary.Get(key, default(V)));
}
public static ExchangeDeclaration GetExchangeDeclaration(this IDictionary <string, object> ctx)
{
return(ctx.Get <ExchangeDeclaration>(RetryKey.ExchangeDeclaration));
}
public static QueueDeclaration GetQueueDeclaration(this IDictionary <string, object> ctx)
{
return(ctx.Get <QueueDeclaration>(RetryKey.QueueDeclaration));
}
public AttachmentInternal(string name, IDictionary <string, object> info)
: this(name, info.GetCast <string>("content_type"))
{
Length = info.GetCast <long>("length");
EncodedLength = info.GetCast <long>("encoded_length");
_digest = info.GetCast <string>("digest");
if (_digest != null)
{
BlobKey = new BlobKey(_digest);
}
string encodingString = info.GetCast <string>("encoding");
if (encodingString != null)
{
if (encodingString.Equals("gzip"))
{
Encoding = AttachmentEncoding.GZIP;
}
else
{
throw new CouchbaseLiteException(StatusCode.BadEncoding);
}
}
var data = info.Get("data");
if (data != null)
{
// If there's inline attachment data, decode and store it:
if (data is string)
{
_data = Convert.FromBase64String((string)data);
}
else
{
_data = data as IEnumerable <byte>;
}
if (_data == null)
{
throw new CouchbaseLiteException(StatusCode.BadEncoding);
}
SetPossiblyEncodedLength(_data.LongCount());
}
else if (info.GetCast <bool>("stub", false))
{
// This item is just a stub; validate and skip it
if (info.ContainsKey("revpos"))
{
var revPos = info.GetCast <int>("revpos");
if (revPos <= 0)
{
throw new CouchbaseLiteException(StatusCode.BadAttachment);
}
RevPos = revPos;
}
}
else if (info.GetCast <bool>("follows", false))
{
// I can't handle this myself; my caller will look it up from the digest
if (Digest == null)
{
throw new CouchbaseLiteException(StatusCode.BadAttachment);
}
if (info.ContainsKey("revpos"))
{
var revPos = info.GetCast <int>("revpos");
if (revPos <= 0)
{
throw new CouchbaseLiteException(StatusCode.BadAttachment);
}
RevPos = revPos;
}
}
else
{
throw new CouchbaseLiteException(StatusCode.BadAttachment);
}
}
public static string GetRoutingKey(this IDictionary <string, object> ctx)
{
return(ctx.Get <string>(RetryKey.RoutingKey));
}
private void OnForceChannelCloseRequested(IDictionary <string, object> command)
{
var channelName = command.Get(Constants.Arguments.Channel);
channels.RemoveChannel(channelName, true);
}
public static IChannelFactory GetChannelFactory(this IDictionary <string, object> ctx)
{
return(ctx.Get <IChannelFactory>(RetryKey.ChannelFactory));
}
private void OnCloseRequested(IDictionary <string, object> command)
{
channels.RemoveChannel(command.Get(Constants.Arguments.Channel));
}
public static ITopologyProvider GetTopologyProvider(this IDictionary <string, object> ctx)
{
return(ctx.Get <ITopologyProvider>(RetryKey.TopologyProvider));
}
public void TestEmptyListFront()
{
var testWindow = new LinkedList <TimeWindowPair>();
var list1 = new LinkedList <EventBean>();
AddToWindow(testWindow, 10L, list1);
var list2 = new LinkedList <EventBean>();
list2.AddLast(_events.Get("a"));
AddToWindow(testWindow, 15L, list2);
var list3 = new LinkedList <EventBean>();
list3.AddLast(_events.Get("c"));
list3.AddLast(_events.Get("d"));
AddToWindow(testWindow, 20L, list3);
var list4 = new LinkedList <EventBean>();
list4.AddLast(_events.Get("e"));
AddToWindow(testWindow, 40L, list4);
var it = new TimeWindowEnumerator(testWindow);
EPAssertionUtil.AssertEqualsExactOrder(
new[]
{
_events.Get("a"),
_events.Get("c"),
_events.Get("d"),
_events.Get("e")
}, it);
}
public virtual TaggingHintKey GetParentHint(TaggingHintKey hintKey)
{
return(parentHints.Get(hintKey));
}
private static void RecursiveAdd(
CodegenMethod methodNode,
IDictionary<string, Type> currentSymbols,
CodegenClassMethods classMethods,
CodegenClassProperties classProperties,
bool isStatic)
{
ISet<string> namesPassed = GetNamesPassed(methodNode);
methodNode.DeepParameters = namesPassed;
IList<CodegenNamedParam> paramset = new List<CodegenNamedParam>(
namesPassed.Count + methodNode.LocalParams.Count);
// add local params
foreach (var named in methodNode.LocalParams) {
paramset.Add(named);
}
// add pass-thru for those methods that do not have their own scope
if (methodNode.OptionalSymbolProvider == null) {
foreach (var nameX in namesPassed) {
var symbolType = currentSymbols.Get(nameX);
if (symbolType == null) {
throw new IllegalStateException(
"Failed to find named parameter '" +
nameX +
"' for method from " +
methodNode.AdditionalDebugInfo);
}
paramset.Add(new CodegenNamedParam(symbolType, nameX));
}
}
else {
currentSymbols = new Dictionary<string, Type>();
methodNode.OptionalSymbolProvider.Provide(currentSymbols);
}
var name = "M" + classMethods.PrivateMethods.Count;
var footprint = new CodegenMethodFootprint(
methodNode.ReturnType,
methodNode.ReturnTypeName,
paramset,
methodNode.AdditionalDebugInfo);
var method = new CodegenMethodWGraph(
name,
footprint,
methodNode.Block,
false,
methodNode.IsOverride,
isStatic);
methodNode.AssignedMethod = method;
classMethods.PrivateMethods.Add(method);
foreach (var child in methodNode.Children) {
RecursiveAdd(
child,
currentSymbols,
classMethods,
classProperties,
isStatic);
}
}
public static IPipeContext GetPipeContext(this IDictionary <string, object> ctx)
{
return(ctx.Get <IPipeContext>(RetryKey.PipeContext));
}
/* (non-Javadoc)
* @see com.itextpdf.html2pdf.css.apply.ICssApplier#apply(com.itextpdf.html2pdf.attach.ProcessorContext, com.itextpdf.html2pdf.html.node.IStylesContainer, com.itextpdf.html2pdf.attach.ITagWorker)
*/
public virtual void Apply(ProcessorContext context, IStylesContainer stylesContainer, ITagWorker tagWorker
)
{
IDictionary <String, String> cssProps = stylesContainer.GetStyles();
IPropertyContainer container = tagWorker.GetElementResult();
if (container != null)
{
if (container is Div)
{
if (!cssProps.ContainsKey(CssConstants.WIDTH) || CssConstants.AUTO.Equals(cssProps.Get(CssConstants.WIDTH)
))
{
((Div)container).SetWidth(DEFAULT_CONTENT_WIDTH_PT);
}
if (!cssProps.ContainsKey(CssConstants.HEIGHT) || CssConstants.AUTO.Equals(cssProps.Get(CssConstants.HEIGHT
)))
{
((Div)container).SetHeight(DEFAULT_CONTENT_HEIGHT_PT);
}
}
WidthHeightApplierUtil.ApplyWidthHeight(cssProps, context, container);
BackgroundApplierUtil.ApplyBackground(cssProps, context, container);
}
}
/// <summary>
/// Ctor.
/// </summary>
/// <param name="viewChain">views</param>
/// <param name="matchRecognizeSpec">specification</param>
/// <param name="agentInstanceContext">The agent instance context.</param>
/// <param name="isUnbound">true for unbound stream</param>
/// <param name="annotations">annotations</param>
/// <exception cref="ExprValidationException">
/// Variable ' + defineItem.Identifier + ' has already been defined
/// or
/// An aggregate function may not appear in a DEFINE clause
/// or
/// Failed to validate condition expression for variable ' + defineItem.Identifier + ': + ex.Message
/// or
/// Aggregation functions in the measure-clause must only refer to properties of exactly one group variable returning multiple events
/// or
/// Aggregation functions in the measure-clause must refer to one or more properties of exactly one group variable returning multiple events
/// or
/// The measures clause requires that each expression utilizes the AS keyword to assign a column name
/// </exception>
/// <throws>ExprValidationException if validation fails</throws>
public EventRowRegexNFAViewFactory(
ViewFactoryChain viewChain,
MatchRecognizeSpec matchRecognizeSpec,
AgentInstanceContext agentInstanceContext,
bool isUnbound,
Attribute[] annotations,
ConfigurationEngineDefaults.MatchRecognize matchRecognizeConfig)
{
var parentViewType = viewChain.EventType;
_matchRecognizeSpec = matchRecognizeSpec;
_isUnbound = isUnbound;
_isIterateOnly = HintEnum.ITERATE_ONLY.GetHint(annotations) != null;
_matchRecognizeConfig = matchRecognizeConfig;
var statementContext = agentInstanceContext.StatementContext;
// Expand repeats and permutations
_expandedPatternNode = RegexPatternExpandUtil.Expand(matchRecognizeSpec.Pattern);
// Determine single-row and multiple-row variables
_variablesSingle = new LinkedHashSet <string>();
ISet <string> variablesMultiple = new LinkedHashSet <string>();
EventRowRegexHelper.RecursiveInspectVariables(_expandedPatternNode, false, _variablesSingle, variablesMultiple);
// each variable gets associated with a stream number (multiple-row variables as well to hold the current event for the expression).
var streamNum = 0;
_variableStreams = new LinkedHashMap <string, Pair <int, bool> >();
foreach (var variableSingle in _variablesSingle)
{
_variableStreams.Put(variableSingle, new Pair <int, bool>(streamNum, false));
streamNum++;
}
foreach (var variableMultiple in variablesMultiple)
{
_variableStreams.Put(variableMultiple, new Pair <int, bool>(streamNum, true));
streamNum++;
}
// mapping of stream to variable
_streamVariables = new SortedDictionary <int, string>();
foreach (var entry in _variableStreams)
{
_streamVariables.Put(entry.Value.First, entry.Key);
}
// determine visibility rules
var visibility = EventRowRegexHelper.DetermineVisibility(_expandedPatternNode);
// assemble all single-row variables for expression validation
var allStreamNames = new string[_variableStreams.Count];
var allTypes = new EventType[_variableStreams.Count];
streamNum = 0;
foreach (var variableSingle in _variablesSingle)
{
allStreamNames[streamNum] = variableSingle;
allTypes[streamNum] = parentViewType;
streamNum++;
}
foreach (var variableMultiple in variablesMultiple)
{
allStreamNames[streamNum] = variableMultiple;
allTypes[streamNum] = parentViewType;
streamNum++;
}
// determine type service for use with DEFINE
// validate each DEFINE clause expression
ISet <string> definedVariables = new HashSet <string>();
IList <ExprAggregateNode> aggregateNodes = new List <ExprAggregateNode>();
var exprEvaluatorContext = new ExprEvaluatorContextStatement(statementContext, false);
_isExprRequiresMultimatchState = new bool[_variableStreams.Count];
for (var defineIndex = 0; defineIndex < matchRecognizeSpec.Defines.Count; defineIndex++)
{
var defineItem = matchRecognizeSpec.Defines[defineIndex];
if (definedVariables.Contains(defineItem.Identifier))
{
throw new ExprValidationException("Variable '" + defineItem.Identifier + "' has already been defined");
}
definedVariables.Add(defineItem.Identifier);
// stream-type visibilities handled here
var typeServiceDefines = EventRowRegexNFAViewFactoryHelper.BuildDefineStreamTypeServiceDefine(statementContext, _variableStreams, defineItem, visibility, parentViewType);
var exprNodeResult = HandlePreviousFunctions(defineItem.Expression);
var validationContext = new ExprValidationContext(
typeServiceDefines,
statementContext.MethodResolutionService, null,
statementContext.SchedulingService,
statementContext.VariableService,
statementContext.TableService, exprEvaluatorContext,
statementContext.EventAdapterService,
statementContext.StatementName,
statementContext.StatementId,
statementContext.Annotations,
statementContext.ContextDescriptor,
statementContext.ScriptingService,
true, false, true, false, null, false);
ExprNode validated;
try {
// validate
validated = ExprNodeUtility.GetValidatedSubtree(ExprNodeOrigin.MATCHRECOGDEFINE, exprNodeResult, validationContext);
// check aggregates
defineItem.Expression = validated;
ExprAggregateNodeUtil.GetAggregatesBottomUp(validated, aggregateNodes);
if (!aggregateNodes.IsEmpty())
{
throw new ExprValidationException("An aggregate function may not appear in a DEFINE clause");
}
}
catch (ExprValidationException ex) {
throw new ExprValidationException("Failed to validate condition expression for variable '" + defineItem.Identifier + "': " + ex.Message, ex);
}
// determine access to event properties from multi-matches
var visitor = new ExprNodeIdentifierCollectVisitor();
validated.Accept(visitor);
var streamsRequired = visitor.StreamsRequired;
foreach (var streamRequired in streamsRequired)
{
if (streamRequired >= _variableStreams.Count)
{
var streamNumIdent = _variableStreams.Get(defineItem.Identifier).First;
_isExprRequiresMultimatchState[streamNumIdent] = true;
break;
}
}
}
_isDefineAsksMultimatches = CollectionUtil.IsAnySet(_isExprRequiresMultimatchState);
_defineMultimatchEventBean = _isDefineAsksMultimatches ? EventRowRegexNFAViewFactoryHelper.GetDefineMultimatchBean(statementContext, _variableStreams, parentViewType) : null;
// assign "prev" node indexes
// Since an expression such as "prior(2, price), prior(8, price)" translates into {2, 8} the relative index is {0, 1}.
// Map the expression-supplied index to a relative index
var countPrev = 0;
foreach (var entry in _callbacksPerIndex)
{
foreach (var callback in entry.Value)
{
callback.AssignedIndex = countPrev;
}
countPrev++;
}
// determine type service for use with MEASURE
IDictionary <string, object> measureTypeDef = new LinkedHashMap <string, object>();
foreach (var variableSingle in _variablesSingle)
{
measureTypeDef.Put(variableSingle, parentViewType);
}
foreach (var variableMultiple in variablesMultiple)
{
measureTypeDef.Put(variableMultiple, new EventType[] { parentViewType });
}
var outputEventTypeName = statementContext.StatementId + "_rowrecog";
_compositeEventType = (ObjectArrayEventType)statementContext.EventAdapterService.CreateAnonymousObjectArrayType(outputEventTypeName, measureTypeDef);
StreamTypeService typeServiceMeasure = new StreamTypeServiceImpl(_compositeEventType, "MATCH_RECOGNIZE", true, statementContext.EngineURI);
// find MEASURE clause aggregations
var measureReferencesMultivar = false;
IList <ExprAggregateNode> measureAggregateExprNodes = new List <ExprAggregateNode>();
foreach (var measureItem in matchRecognizeSpec.Measures)
{
ExprAggregateNodeUtil.GetAggregatesBottomUp(measureItem.Expr, measureAggregateExprNodes);
}
if (!measureAggregateExprNodes.IsEmpty())
{
var isIStreamOnly = new bool[allStreamNames.Length];
CompatExtensions.Fill(isIStreamOnly, true);
var typeServiceAggregateMeasure = new StreamTypeServiceImpl(allTypes, allStreamNames, isIStreamOnly, statementContext.EngineURI, false);
var measureExprAggNodesPerStream = new Dictionary <int, IList <ExprAggregateNode> >();
foreach (var aggregateNode in measureAggregateExprNodes)
{
// validate absence of group-by
aggregateNode.ValidatePositionals();
if (aggregateNode.OptionalLocalGroupBy != null)
{
throw new ExprValidationException("Match-recognize does not allow aggregation functions to specify a group-by");
}
// validate node and params
var count = 0;
var visitor = new ExprNodeIdentifierVisitor(true);
var validationContext = new ExprValidationContext(
typeServiceAggregateMeasure,
statementContext.MethodResolutionService, null,
statementContext.SchedulingService,
statementContext.VariableService,
statementContext.TableService,
exprEvaluatorContext,
statementContext.EventAdapterService,
statementContext.StatementName,
statementContext.StatementId,
statementContext.Annotations,
statementContext.ContextDescriptor,
statementContext.ScriptingService,
false, false, true, false, null, false);
foreach (var child in aggregateNode.ChildNodes)
{
var validated = ExprNodeUtility.GetValidatedSubtree(ExprNodeOrigin.MATCHRECOGMEASURE, child, validationContext);
validated.Accept(visitor);
aggregateNode.SetChildNode(count++, new ExprNodeValidated(validated));
}
validationContext = new ExprValidationContext(
typeServiceMeasure, statementContext.MethodResolutionService, null,
statementContext.SchedulingService,
statementContext.VariableService,
statementContext.TableService,
exprEvaluatorContext,
statementContext.EventAdapterService,
statementContext.StatementName,
statementContext.StatementId,
statementContext.Annotations,
statementContext.ContextDescriptor,
statementContext.ScriptingService,
false, false, true, false, null, false);
aggregateNode.Validate(validationContext);
// verify properties used within the aggregation
var aggregatedStreams = new HashSet <int>();
foreach (var pair in visitor.ExprProperties)
{
aggregatedStreams.Add(pair.First);
}
int?multipleVarStream = null;
foreach (int streamNumAggregated in aggregatedStreams)
{
var variable = _streamVariables.Get(streamNumAggregated);
if (variablesMultiple.Contains(variable))
{
measureReferencesMultivar = true;
if (multipleVarStream == null)
{
multipleVarStream = streamNumAggregated;
continue;
}
throw new ExprValidationException("Aggregation functions in the measure-clause must only refer to properties of exactly one group variable returning multiple events");
}
}
if (multipleVarStream == null)
{
throw new ExprValidationException("Aggregation functions in the measure-clause must refer to one or more properties of exactly one group variable returning multiple events");
}
var aggNodesForStream = measureExprAggNodesPerStream.Get(multipleVarStream.Value);
if (aggNodesForStream == null)
{
aggNodesForStream = new List <ExprAggregateNode>();
measureExprAggNodesPerStream.Put(multipleVarStream.Value, aggNodesForStream);
}
aggNodesForStream.Add(aggregateNode);
}
var factoryDesc = AggregationServiceFactoryFactory.GetServiceMatchRecognize(_streamVariables.Count, measureExprAggNodesPerStream, typeServiceAggregateMeasure.EventTypes);
_aggregationService = factoryDesc.AggregationServiceFactory.MakeService(agentInstanceContext);
_aggregationExpressions = factoryDesc.Expressions;
}
else
{
_aggregationService = null;
_aggregationExpressions = Collections.GetEmptyList <AggregationServiceAggExpressionDesc>();
}
// validate each MEASURE clause expression
IDictionary <string, object> rowTypeDef = new LinkedHashMap <string, object>();
var streamRefVisitor = new ExprNodeStreamUseCollectVisitor();
foreach (var measureItem in matchRecognizeSpec.Measures)
{
if (measureItem.Name == null)
{
throw new ExprValidationException("The measures clause requires that each expression utilizes the AS keyword to assign a column name");
}
var validated = ValidateMeasureClause(measureItem.Expr, typeServiceMeasure, variablesMultiple, _variablesSingle, statementContext);
measureItem.Expr = validated;
rowTypeDef.Put(measureItem.Name, validated.ExprEvaluator.ReturnType);
validated.Accept(streamRefVisitor);
}
// Determine if any of the multi-var streams are referenced in the measures (non-aggregated only)
foreach (var @ref in streamRefVisitor.Referenced)
{
var rootPropName = @ref.RootPropertyNameIfAny;
if (rootPropName != null)
{
if (variablesMultiple.Contains(rootPropName))
{
measureReferencesMultivar = true;
break;
}
}
var streamRequired = @ref.StreamReferencedIfAny;
if (streamRequired != null)
{
var streamVariable = _streamVariables.Get(streamRequired.Value);
if (streamVariable != null)
{
var def = _variableStreams.Get(streamVariable);
if (def != null && def.Second)
{
measureReferencesMultivar = true;
break;
}
}
}
}
_isCollectMultimatches = measureReferencesMultivar || _isDefineAsksMultimatches;
// create rowevent type
var rowEventTypeName = statementContext.StatementId + "_rowrecogrow";
_rowEventType = statementContext.EventAdapterService.CreateAnonymousMapType(rowEventTypeName, rowTypeDef);
// validate partition-by expressions, if any
if (!matchRecognizeSpec.PartitionByExpressions.IsEmpty())
{
var typeServicePartition = new StreamTypeServiceImpl(parentViewType, "MATCH_RECOGNIZE_PARTITION", true, statementContext.EngineURI);
var validated = new List <ExprNode>();
var validationContext = new ExprValidationContext(
typeServicePartition, statementContext.MethodResolutionService, null,
statementContext.SchedulingService, statementContext.VariableService, statementContext.TableService,
exprEvaluatorContext, statementContext.EventAdapterService, statementContext.StatementName,
statementContext.StatementId, statementContext.Annotations, statementContext.ContextDescriptor,
statementContext.ScriptingService,
false, false, true, false, null, false);
foreach (var partitionExpr in matchRecognizeSpec.PartitionByExpressions)
{
validated.Add(ExprNodeUtility.GetValidatedSubtree(ExprNodeOrigin.MATCHRECOGPARTITION, partitionExpr, validationContext));
}
matchRecognizeSpec.PartitionByExpressions = validated;
}
// validate interval if present
if (matchRecognizeSpec.Interval != null)
{
var validationContext =
new ExprValidationContext(
new StreamTypeServiceImpl(statementContext.EngineURI, false),
statementContext.MethodResolutionService, null, statementContext.SchedulingService,
statementContext.VariableService, statementContext.TableService, exprEvaluatorContext,
statementContext.EventAdapterService, statementContext.StatementName, statementContext.StatementId,
statementContext.Annotations, statementContext.ContextDescriptor, statementContext.ScriptingService,
false, false, true, false, null, false);
matchRecognizeSpec.Interval.Validate(validationContext);
}
}
private MediaFolderInfo InternalCopyFolder(TreeNode <MediaFolderNode> sourceNode, string destPath, DuplicateEntryHandling dupeEntryHandling, IList <DuplicateFileInfo> dupeFiles)
{
// Get dest node
var destNode = _folderService.GetNodeByPath(destPath);
// Dupe handling
if (destNode != null && dupeEntryHandling == DuplicateEntryHandling.ThrowError)
{
throw _exceptionFactory.DuplicateFolder(sourceNode.Value.Path, destNode.Value);
}
var doDupeCheck = destNode != null;
// Create dest folder
if (destNode == null)
{
destNode = CreateFolder(destPath);
}
var ctx = _fileRepo.Context;
// INFO: we gonna change file name during the files loop later.
var destPathData = new MediaPathData(destNode, "placeholder.txt");
// Get all source files in one go
var files = _searcher.SearchFiles(
new MediaSearchQuery {
FolderId = sourceNode.Value.Id
},
MediaLoadFlags.AsNoTracking | MediaLoadFlags.WithTags).Load();
IDictionary <string, MediaFile> destFiles = null;
HashSet <string> destNames = null;
if (doDupeCheck)
{
// Get all files in destination folder for faster dupe selection
destFiles = _searcher.SearchFiles(new MediaSearchQuery {
FolderId = destNode.Value.Id
}, MediaLoadFlags.None).ToDictionarySafe(x => x.Name);
// Make a HashSet from all file names in the destination folder for faster unique file name lookups
destNames = new HashSet <string>(destFiles.Keys, StringComparer.CurrentCultureIgnoreCase);
}
// Holds source and copy together, 'cause we perform a two-pass copy (file first, then data)
var tuples = new List <(MediaFile, MediaFile)>(500);
// Copy files batched
foreach (var batch in files.Slice(500))
{
foreach (var file in batch)
{
destPathData.FileName = file.Name;
// >>> Do copy
var copy = InternalCopyFile(
file,
destPathData,
false /* copyData */,
dupeEntryHandling,
() => destFiles?.Get(file.Name),
UniqueFileNameChecker,
out var isDupe);
if (copy != null)
{
if (isDupe)
{
dupeFiles.Add(new DuplicateFileInfo
{
SourceFile = ConvertMediaFile(file, sourceNode.Value),
DestinationFile = ConvertMediaFile(copy, destNode.Value),
UniquePath = destPathData.FullPath
});
}
if (!isDupe || dupeEntryHandling != DuplicateEntryHandling.Skip)
{
// When dupe: add to processing queue only if file was NOT skipped
tuples.Add((file, copy));
}
}
}
// Save batch to DB (1st pass)
ctx.SaveChanges();
// Now copy file data
foreach (var op in tuples)
{
InternalCopyFileData(op.Item1, op.Item2);
}
// Save batch to DB (2nd pass)
ctx.SaveChanges();
ctx.DetachEntities <MediaFolder>();
ctx.DetachEntities <MediaFile>();
tuples.Clear();
}
// Copy folders
foreach (var node in sourceNode.Children)
{
destPath = destNode.Value.Path + "/" + node.Value.Name;
InternalCopyFolder(node, destPath, dupeEntryHandling, dupeFiles);
}
return(new MediaFolderInfo(destNode));
void UniqueFileNameChecker(MediaPathData pathData)
{
if (destNames != null && _helper.CheckUniqueFileName(pathData.FileTitle, pathData.Extension, destNames, out var uniqueName))
{
pathData.FileName = uniqueName;
}
}
}
public object GetMap(IDictionary<string, object> map)
{
// If the map does not contain the key, this is allowed and represented as null
var wrapper = (EventBean[]) map.Get(propertyName);
return BaseNestableEventUtil.GetBNArrayPropertyUnderlying(wrapper, index);
}
public static string GetExchangeName(this IDictionary <string, object> ctx)
{
return(ctx.Get <string>(RetryKey.ExchangeName));
}
/// <summary>Gets a shorthand resolver.</summary>
/// <param name="shorthandProperty">the property</param>
/// <returns>the shorthand resolver</returns>
public static IShorthandResolver GetShorthandResolver(String shorthandProperty)
{
return(shorthandResolvers.Get(shorthandProperty));
}
