[ht::head {Creating Folders and Entries}] <%nochildlist%> :navtop :heading Creating a new folder When you are logged in and you have the access to create a new folder or entry under the folder that you are viewing there will be a set of links under the File section of the entry menu popup . [ht::screenshot images/entrymenu.png] If you just want to make a simple Folder or upload a File then choose the "New Folder" or "New File" menu item.
Selecting the "Create a folder" link will take you to the create folder form: [ht::screenshot images/newfolder.png] Enter a name and an optional description, date range and lat/lon bounding box. The tags allow you to add one or more tag properties to the folder. This can aid in search, etc. Typing in the box will bring up a list of existing tags to choose from or just add a new one. :p The checkbox above the Description field toggles the display of the this new folder to use the wiki text. See the userguide section on Wiki text for more information. :p The Order is a numeric value that can be used to order this folder in its parent entry listing. :heading Uploading files To upload a file to a RAMADDA repository you create a new Entry. From the File menu select "New File". :p The Create Entry form allows you to upload a file or specify a URL. If you are a site administrator you can also specify a path to a file on the server machine. [ht::screenshot images/newfile.png] The minimal you need to enter here is the file or URL. The other fields are optional. If you do not enter a name then the file name is used.
The upload settings allows you to control various aspects of the upload. [ht::screenshot images/uploadsettings.png]


Before Change
// Implement the following 2 methods to make pickling happy in python 2
def __getstate__(self):
return dict([x, getattr(self, x)] for x in self.__slots__)
def __setstate__(self, d):
for key in d:
setattr(self, key, d[key])
After Change
Note that the bytes returned by the Python pickle.dumps is not
the same as the buffer returned by this function.
"""
buffer = bytearray(self.bytesize())
self.serialize(buffer)
return buffer
def __setstate__(self, buffer):
"""
This function is called when unpickling the MinHash object.


{% extends 'base.html' %}
{% block title %}Internal Server Error – 500{% endblock %}
{% block site_wrapper %}
We’re sorry, but the site you are trying to access is currently experiencing problems.
We apologize for any inconvenience. Please try back again later.
{% endblock %}


Staff:
Our staff is made out of multiple friendly members that help keep the community and conversations clean. If you need any help you can just call any of them.
Discord Server:
Due to Discord being easy to use and reliable, we use it as a center for conversations. Join in and have a chat!
Contact Us:
You can contact the Owner/Server manager directly here:
Mail
Steam
Telegram


Skipper is a Social Learning Platform for Homeschoolers, Co-ops & Communities. At Skipper I'm in charge of full development cycle, from idea to release
drop2amz is a unique all-in-one solution for full-scale drop-shipping on Amazon. Trusted by thousands of sellers worldwide, our platform continuously manages millions of products and growing
Synnergia Solutions is a local software development agency with worldwide ambitions. Since 2013 we had a number of multi-million and billion dollar companies amongst our clients and have been working on numerous successful external and internal projects


Jingle Smash
Smash all the blue crystal boxes with just three ornaments.
loading
VR not supported, play anyway
by Josh Marinacci


--- layout: archive title: Zulip Chat Archive permalink: /stream/113489-new-members/topic/simple.20arithmetic.20proofs.html ---
Is there some tactic to discharge simple proofs like example (n: nat) (p: nat) : 2 < 1 + (1 + (1 + (1 + (n + p))))
? I tried ring
and abel
but they don't solve it, just simplify the statement
Maybe omega
?
omega
and linarith
can both handle that.
Last updated: Apr 24 2020 at 19:02 UTC


BOTH HOUSE AND TECHNO ARE DIVIDED IN A TOTAL OF 49 SUBGENRES, SORTED BY YEAR OF ORIGIN AND MUSICAL INTENSITY.  THESE ATTRIBUTES ARE COLLECTED BY THE ECHO NEST API. FOR EARCH OF THE SPECIFIED SUB-GENRES, A FIXED AMOUNT OF SONGS WITH A TOP RATING IS USED TO DETERMINE THE INTENSITY COEFFICIENT.
 DOUBLE CLICKING A SUB-GENRE LEADS TO THE ARTISTS PAGE IN WHICH ARTIST INFORMATION ABOUT THE SPECIFIED SUB-GENRE CAN BE FOUND.


The Suggested Web Page lets you set which web page to suggest to a vistor. The title and description will be displayed, and when they click, they will be taken to the specified URL.


This tool helps when you want to avoid interface{} and type assertions or
writing definitions by hand. The translater makes some assumptions, so be sure to check the results (and then use go fmt.)
1. Type in a name for the Go type to generate.
2. Paste in your JSON.
3. Click the Convert button.
4. Grab your Go code from the Golang tab.
5. Rinse and repeat.


GRR is forensic framework focused on scalability enabling powerful analysis. To achieve this it has a lot of moving parts and a rich API. This document examines each subsystem and explains how they interact. We then proceed to examine the implementation from a developer’s point of view, to assist external contributors to come up to speed with the code-base.
GRR Component Overview
The following describes the components that make up the GRR system. Since GRR is designed to be scalable, each component can exist on its own machine in the data center. Alternatively, for smaller installations, each component can run as a separate server process, or even all components can run inside the same process in different threads.
The main components running components are:
- Client
-
The GRR client agent is deployed on corporate assets using the usual mechanism for software distribution and updates (e.g. SMS, apt). The client communicates with the front-end server using a HTTP POST request. The request sends and receives GRR messages from the server (more detail on this below). All communication with the front end servers is encrypted.
- Front End Servers
-
The front end servers' main task is to decrypt POST requests from the client, un-bundle the contained messages and queues these on the data store. The front end also fetches any messages queued for the client and sends them to the client.
- Datastore
-
The data store acts both as a central storage component for data, and as a communication mechanism for all the components. The data is modeled after an RDF datastore using the AFF4 data model (See AFF4 Data Model).
- Console
-
The console is the central application which enables the incident responder or forensic analyst to interact with the system. The consoles allows for analysis tasks to be queued for the clients, and results of previous stored analysis to be examined. GRR has both a GUI and a text based console application.
- Worker
-
In order to remain scalable, the front end does not do any processing of data, preferring to offload processing to special worker components. The number of workers can be tuned in response to increased workload. Workers typically check queues in the data stores for responses from the client, process those and re-queue new requests for the clients (See [Flows] and [Queues]).
GRR Messages
On the wire, the client and server interchange messages. We term the messages send from server to the client requests, while messages send from the client to the server are responses. Requests sent to the client, ask the client to perform some action, which we term the client action, for example ListDirectory. A single request may elicit multiple responses.
For example, the request message ListDirectory will elicit a response for each file in the directory (potentially thousands). Requests and responses are tracked using an incremental request_id and response_id.
In order to indicate when all responses have been sent for a particular request, the client sends a special STATUS message as the last response. In the event of errors, the message contains details of the error (including backtrace). If the action completed successfully, an OK status is returned.
Messages are encoded as GrrMessage protobufs:
session_id |
A unique integer for all packets generated by this flow. |
name |
The name of the Action to be called on the client (See below). |
args |
A serialized protobuf which will be interpreted by the Action. |
request_id |
An incrementing number of this request (see below) |
response_id |
An incrementing number of the response (see below) |
Figure 2 illustrates a typical sequence of messages. Request 1 was sent from the server to the client, and elicited 3 responses, in addition to a status message.
When the server sends the client messages, the messages are tagged in the data store with a lease time. If the client does not reply for these requests within the lease time, the requests become available for lease again. This is designed for the case of the client rebooting or losing connectivity part way through running the action. In this case, the request is re-transmitted and the action is run again.
Client Communication and Encryption
TBD
Flows.
Typically when we want to run an analysis on the client, we need to go through a process where a number of requests are issued, their responses are examined, and new requests are issued. This round trip to the client may happen many times.
If it inefficient to dedicate server resources to wait for the client to complete any particular request. The client may lose connectivity or disappear at any time, and leave server resources (such as memory) in use for prolonged period.
GRR solves the problem by using a suspendable execution model. We term this construct a Flow. The flow is a state machine which receives responses to requests into well defined state methods. The flow object can be pickled (serialized) between state executions to disk. This allows the server to suspect the current execution flow with the client indefinitely with no server resources committed.
Figure 4 illustrates a typical flow:
-
We begin in the Start state, where we issue a request to the client to calculate the hash of a file. The responses to the request (when they arrive back from the client) will be fed into the CheckHash state. Once the requests are send, the flow can be serialized indefinitely.
-
When the hash response arrives from the client, and we do not have the hash in the database (i.e. we do not have a copy of this file), the flow will issue a ReadBuffer request for the first buffer of the file.
-
When the response is returned, the buffer is written to disk, and the next buffer is requested.
-
Once the entire length of the file is retrieved, we can verify the buffer hash and complete the flow.
|
The above flow is rather inefficient since it requires a round trip for each buffer fetched. In practice, the GetFile flow will queue up a full window of ReadBuffer requests in order to make better use of client bandwidth. When designing real flows, it is always necessary to minimize round trips. |
Since multiple flows can run simultaneously on the same client, it is necessary to be able to distinguish between flows. Flows have a session_id which is a randomly generated ID to designate all requests and responses belonging to this flow. The client simply copies the session id from requests to any responses it generates, to ensure they will arrive at the respective flow. For example, a session id may be ‘W:1213243AE’.
Well Known Flows and the Event System
The GRR client receives requests with a flow session id, which it copies to the response. This session id is used to route the response to the correct flow. This means that typically, the client is unable to just send a message into any running flow, since it would require guessing the session id for the flow. This is a good thing since it protects flows from malicious clients.
However, there is a need sometimes for the client to send unsolicited messages to the server (For example during enrollment). In order for the responses to be routed they must have a correct session id.
The solution is to have a second class of flows on the server called Well Known Flows. These flows have a well known session id so messages can be routed to them without the flow needing to send requests for them first. Since any client or server can send messages to a well known flow, it is impossible for these to maintain state (since its the same instance of the flow used to process many clients' messages. Therefore well known flows are stateless.
A well known flow typically is used simply to launch another flow or to process an event. For example:
| A new well known flow is created by extending the WellKnownFlow baseclass. | |
| The Well known session id of this flow is "CA:Enrol". Messages to this queue will be routed to this flow. | |
| We expect to receive a Certificate protobuf for this flow - this is essentially a CSR for the requesting client. | |
| We open the AFF4 object for this client. | |
| If this client has no certificate already, we launch the real CAEnroler flow to talk with this client. Note that the CAEnroler flow is a regular flow with a random session_id - that ensure no other clients can interfere with this enrollment request. |
On top of the the Well known flow system GRR implements an event dispatching system. This allows any component to declare an event it is interested in, and have any other component broadcast the event.
For example, when a new client enrolls we wish to run the Interrogate flow automatically for it (so we can query it for hostname, usernames etc):
| An event listener is a class which extends flow.EventListener. | |
| It will listen to any of these events. Note we also need to have a unique well_known_session_id since an Event Listener is just a specialized Well Known Flow. | |
| When an event called "ClientEnrollment" is broadcast, this EventListener will receive the message and automatically run the Interrogate flow against this client. |
The event can now be broadcast from any other flow:
Hunts
In order to be able to search for malicious code and abnormal behavior amongst the entire fleet of clients, GRR has implemented the concept of hunts. Hunts are essentially flows that run on multiple clients at the same time.
At the moment, hunts are regarded as rather high impact since they can affect many clients at once so scheduling new hunts is restricted to console users. In order to schedule a hunt, this is the process:
Import the hunts file and create a new hunt (This example uses the SampleHunt, replace with a hunt of your choice):
This creates the SampleHunt, possible parameters:
-
client_limit to limit the number of clients this hunt will be scheduled on for experiments.
-
expiry_time gives the time this hunt will be active (in seconds).
Next you have to create rules to indicate which clients the hunt will be run on. Rules either compare fields stored in the client description to integer values or match regular expressions against them:
The two rules above will match clients that run windows and have an OS_RELEASE of 7.
Next, you add the rules to the hunt:
You can call AddRule more than once. The hunt will be triggered if all the rules of one AddRule call match at the same time. So you can do:
to start a hunt on windows clients that have either OS_VERSION 7 or 8.
If you are unsure about your rules, you can call
This will show you how many clients in the db match your rules and give you some matching sample clients. Note that this will open all the clients and will therefore take a while if you have a lot of clients in the database.
Once you are happy with your rules, you upload the hunt to the foreman:
At this point, matching clients will pick up and run the hunt and you can see the progress in the UI.
If you want to stop a running hunt and remove the foreman rules again, use
Queues
GRR Supports multiple processing queues on the server. This allows specialized workers to be used for specific tasks, independently routing all messages to these workers.
For example Figure 3 illustrates three distinct types of workers. The general purpose workers retrieve messages from the general queue named "W". A specialized worker responsible for CA enrollments communicates to the client on the queue "CA" while an interactive worker has its own queue for the client.
It is also possible to run special purpose workers for example for debugging or special flow processing (i.e. workers with custom flows which are not found in the standard workers). These workers can be started with the command line parameter --worker_queue_name to specify a custom name. The special worker will then attach to the regular messaging system and be able to issue flows to the client without interference from other workers.
Additionally each client has a queue for messages intended to it (i.e. client requests). This queue can be examined using the Debug Client Requests option in the GUI:
The Figure shows three client requests outstanding for this client. The client is currently offline and so has requests queued for it when it returns. We can see two regular requests directed to the queue "W" - a ListProcesses request and a NetStat request. There is also a special request directed at the queue DEBUG for ExecuteBinaryRequest.
AFF4 Data Model
AFF4 was first published in 2008 as an extensible, modern forensic storage format. The AFF4 data model allows the representation of arbitrary objects and the association of these with semantic meaning. The AFF4 data model is at the heart of GRR and is essential for understanding how GRR store, analyzes and represents forensic artifacts.
AFF4 is an object oriented model. This means that all entities are just different types of AFF4 objects. An AFF4 object is simply an entity, addressable by a globally unique name, which has attributes attached to it, as well as behaviors.
Each AFF4 object has a unique urn by which it can be addressed. AFF4 objects also have optional attributes which are defined in the object’s Schema. For example consider the following definition of an AFF4 object representing a GRR Client:
| An AFF4 object is simply a class which extends the AFF4Object base class. | |
| Each AFF4 object contains a Schema - in this case the Schema extends the base AFF4Object schema - this means this object can contains the attributes on the base class in addition to these attributes. Attributes do not need to be set. | |
| Attributes have both a name ("metadata:cert") as well as a type ("RDFX509Cert"). In this example, the VFSGRRClient object will contain a CERT attribute which will be an instance of the type RDFX509Cert. | |
| An attribute can also be marked as ready for indexing. This means that whenever this attribute is updated, the corresponding index is also updated. |
The figure above illustrates an AFF4 Object of type VFSGRRClient. It has a URN of "aff4:/C.880661da867cfebd". The figure also list all the attributes attached to this object. Notice how some attributes are listed under the heading AFF4Object (since they are defined at that level) and some are listed under VFSGRRClient since they are defined under the VFSGRRClient schema.
The figure also gives an Age for each attribute. This is the time when the attribute was created. Since GRR deals with fluid, constantly changing systems, each fact about the system must be tagged with the point in time where that fact was known. For example, in a future time, the hostname may change. In that case we will have several versions for the HOSTNAME attribute, each correct for that point in time. We consider the entire object to have a new version when a versioned attribute changes.
The Figure above shows a process listing performed on this client. The view we currently see shows the the process listing at one point in time, but we can also see a UI offering to show us previous versions of the same object.
AFF4 objects take care of their own serialization and unserialization and the data store technology is abstracted. Usually AFF4 objects are managed using the aff4 FACTORY:
In [8]: pslist = aff4.FACTORY.Open("aff4:/C.d74adcb3bef6a388/devices\ /memory/pslist", mode="r", age=aff4.ALL_TIMES) In [9]: pslist Out[9]: <AFF4MemoryStream@7F2664442250 = aff4:/C.d74adcb3bef6a388/devices/memory/pslist> In [10]: print pslist.read(500) Offset(V) Offset(P) Name PID PPID Thds Hnds Time ---------- ---------- -------------------- ------ ------ ------ ------ ------------------- 0xfffffa8001530b30 0x6f787b30 System 4 0 97 520 2012-05-14 18:21:33 0xfffffa80027119d0 0x6e5119d0 smss.exe 256 4 3 33 2012-05-14 18:21:34 0xfffffa8002ce3060 0x6dee3060 csrss.exe 332 324 9 611 2012-05-14 18:22:25 0xfffffa8002c3 In [11]: s = pslist.Get(pslist.Schema.SIZE) In [12]: print type(s) <class 'grr.lib.aff4.RDFInteger'> In [13]: print s 4938 In [14]: print s.age 2012-05-21 14:48:20 In [15]: for s in pslist.GetValuesForAttribute(pslist.Schema.SIZE): ....: print s, s.age 4938 2012-05-21 14:48:20 4832 2012-05-21 14:20:30 4938 2012-05-21 13:53:05
| We have asked the aff4 factory to open the AFF4 object located at the unique location of aff4:/C.d74adcb3bef6a388/devices/memory/pslist for reading. The factory will now go to the data store, and retrieve all the attributes which comprise this object. We also indicate that we wish to examine all versions of all attributes on this object. | |
| We receive back an AFF4 object of type AFF4MemoryStream. This is a stream (i.e. it contains data) which stores all its content in memory. | |
| Since it is a stream, it also implements the stream interface (i.e. supports reading and seeking). Reading this stead gives back the results from running Volatility’s pslist against the memory of the client. | |
| The SIZE attribute is attached to the stream and indicates how much data is contained in the stream. Using the Get() interface we retrieve the most recent one. | |
| The attribute is strongly typed, and it is an instance of an RDFInteger. | |
| The RDFInteger is able to stringify itself sensibly. | |
| All attributes carry the timestamp when they were created. The last time the SIZE attribute was updated was when the object was written to last. | |
| We can now retrieve all versions of this attribute - The pslist Flow was run on this client 3 times at different dates. Each time the data is different. |
Client Path Specifications
One of the nice things about the GRR client is the ability to nest file readers. For example, we can read files inside an image using the sleuthkit and also directly through the API. We can read registry keys using REGFI from raw registry files as well as using the API. The way this is implemented is using a pathspec.
Pathspecs
The GRR client has a number of drivers to virtualize access to different objects create a Virtual File System (VFS) abstraction. These are called VFS Handlers and they provide typical file-like operations (e.g. read, seek, tell and stat). It is possible to recursively apply different drivers in the correct order to arrive at a certain file like object. In order to specify how drivers should be applied we use Path Specifications or pathspec.
Each VFS handler is constructed from a previous handler and a pathspec. The pathspec is just a collection of arguments which make sense to the specific VFS handler. The type of the handler is carried by the pathtype parameter:
- pathtype: OS
-
Implemented by the grr.client.vfs_handlers.file module is a VFS Handler for accessing files through the normal operating system APIs.
- pathtype: TSK
-
Implemented by the grr.client.vfs_handlers.sleuthkit module is a VFS Handler for accessing files through the sleuthkit. This Handle depends on being passed a raw file like object, which is interpreted as the raw device.
- pathtype: MEMORY
-
Implemented by the grr.client.vfs_handlers.memory module is a VFS Handler implementing access to the system’s raw memory. This is used by the volatility plugins for memory analysis.
A pathspec is a list of components. Each component specifies a way to derive a new python file-like object from the previous file-like object. For example, image we have the following pathspec:
path: /dev/sda1 pathtype: OS nested_path: { path: /windows/notepad.exe pathtype: TSK }
This opens the raw device /dev/sda1 using the OS driver. The TSK driver is then given the previous file like object and the nested pathspec instructing it to open the /windows/notepad.exe file after parsing the filesystem in the previous step.
This can get more involved, for example:
path: /dev/sda1 pathtype: OS nested_path: { path: /windows/system32/config/system pathtype: TSK nested_path: { path: SOFTWARE/MICROSOFT/WINDOWS/ pathtype: REGISTRY } }
Which means to use TSK to open the raw registry file and then REGFI to read the key from it (note that is needed because you generally cant read the registry file while the system is running).
Pathspec transformations
The pathspec tells the client exactly how to open the required file, by nesting drivers on the client. Generally, however, the server has no prior knowledge of files on the client, therefore the client needs to transform the server request to the pathspec that makes sense for the client. The following are the transformations which are applied to the pathspec by the client.
File Case Correction and path separator correction
Some filesystems are not case sensitive (e.g. NTFS). However they do preserve file cases. This means that the same pathspecs with different case filename will access the same file on disk. This file however, does have a well defined and unchanging casing. The client can correct file casing, e.g.:
path: c:\documents and settings\ pathtype: OS
Is corrected to the normalized form:
path: /c/Documents and Settings/ pathtype: OS
Filesystem mount point conversions
Sometimes the server requires to read a particular file from the raw disk using TSK. However, the server generally does not know where the file physically exists without finding out the mounted devices and their mount points. This mapping can only be done on the client at request runtime. When the top level pathtype is TSK, the client knows that the server intends to read the file through the raw interface, and therefore converts the pathspec to the correct form using the mount points information. For example:
path: /home/user/hello.txt pathtype: TSK
Is converted to:
path: /dev/sda2 pathtype: OS nested_path: { path: /user/hello.txt pathtype: TSK }
UUIDs versus "classical" device nodes
External disks can easily get re-ordered at start time, so that path specifiers containing /dev/sd? etc. may not be valid anymore after the last reboot. For that reason the client will typically replace /dev/sda2 or similar strings with /dev/disk/by-uuid/[UUID] on Linux or other constructions (e.g. pathtype: uuid) for all clients.
Life of a client pathspec request
How are the pathspecs sent to the client and how are they related to the aff4 system. The figure below illustrate a typical request - in this case to list a directory:
-
A ListDirectory Flow is called with a pathspec of:
path: c:\docume~1\bob\ pathtype: OS
-
The flow sends a request for the client action ListDirectory with the provided pathspec.
-
Client calls VFSOpen(pathspec) which opens the file, and correct the pathspec to:
path: c:\Documents and Settings\Bob\ pathtype: OS
-
Client returns StatResponse for this directory with the corrected pathspec.
-
The client AFF4 object maps the pathspec to an AFF4 hierarchy in the AFF4 space. The server flow converts from client pathspec to the aff4 URN for this object using the PathspecToURN() API. In this case a mapping is created for files read through the OS apis under /fs/os/. Note that the AFF4 URN created contains the case corrected - expanded pathspec:
urn = GRRClient.PathspecToURN(pathspec) urn = aff4:/C.12345/fs/os/c/Documents and Settings/Bob
-
The server now creates this object, and stores the corrected pathspec as a STAT AFF4 attribute.
Client pathspec conversions can be expensive so the next time the server uses this AFF4 object for a client request, the server can simply return the client the corrected pathspec. The corrected pathspec has the LITERAL option enabled which prevents the client from applying any corrections.
Foreman
The Foreman is a client scheduling service. At a regular intervals (defaults to every 50 minutes) the client will report in asking if there are Foreman actions for it. At the time of this check in, the Foreman will be queried to decide if there are any jobs that match the host, if there are, appropriate flows will be created for the client. This mechanism is generally used by Hunts to schedule flows on a large number of clients.
The foreman maintains a list of rules, if the rule matches a client when it checks in, the specified flow will execute on the client. The rules work against AFF4 attributes allowing for things like "All XP Machines" or "All OSX machines installed after 01.01.2011".
The foreman check in request is a special request made by the client that communicates with a Well Known Flow (W:Foreman). When the server sees this request it does the following:
-
Determines how long since this client did a Foreman check-in.
-
Determines the set of that are non-expired and haven’t previously been checked by the client.
-
Matches those rules against the client’s attributes to determine if there is a match.
-
If there is a match, run the associated flow.
The reason for the separate Foreman check-in request is that the rule matching can be expensive when you have a lot of clients, so having these less frequent saves a lot of processing.
Reporting
The current (September 2012) reporting capabilities of GRR are very limited. We have a small set of reports defined in lib/aff4_objects/reports.py that can be used and serve as examples for extension. There is no UI for these components currently, but they can be run from the Console.
r = reports.ClientListReport(access_control.ACLToken()) r.Run<EMAIL_ADDRESS>open("client_list.csv", "w").write(r.AsCsv())
| Create a report that lists all clients and gives basic information about them. We pass an empty authorization token. | |
| Run the report. This opens all client objects, so may take some time if you have a lot of clients. | |
| Mail the output of the report to<EMAIL_ADDRESS>| |
| Dump the CSV output of the report to client_list.csv. |
Using these report classes as a basis, it should be relatively easy to extend the reports to do whatever you need.
Authorization and Auditing
GRR contains support for a full authorization and audit API (even for console users) and is implemented in an abstraction called a Security Manager. This Security Manager shipped with GRR (September 2012) does not make use of these APIs and is open by default. However, a deployment may build their own Security Manager which implements the authorization semantics they require.
This infrastructure is noticeable throughout much of the code, as access to any data within the system requires the presence of a "token". The token contains the user information and additionally information about the authorization of the action. This passing of the token may seem superfluous with the current implementation, but enables developers to create extensive audit capabilities and interesting modes of authorization.
By default, GRR should use data_store.default_token if one is not provided. To ease use this variable is automatically populated by the console if --client is used.
Token generation is done using the access_control.ACLToken.
Developer Information
The following examples detail how developers can extend the GRR framework for implementing new features.
Adding Flows
The most common task is to add a new flow. The following is an example of a non-trivial flow from the GRR source code:
| A flow is simply a class which extends flow.GRRFlow. | |
| By specifying a category, the GUI can use this flow automatically. | |
| A state method is decorated with the StatHandler decorator. This also specifies all the possible other states that can be transitioned from this state. | |
| The CallFlow method delegates execution to another flow. The responses from this flows will be fed back into the End state. |
Adding a new flow source file
To add a new flow source file: 1. Create the source file in lib/flows/general/, e.g. my_flow.py 2. Add an import statement to lib/flows/general/init.py, e.g
Writing a new flow
-
Create the flow class:
-
Define the category the flow is part of:
-
Define the flow type information. The web-based UI will generate the necessary flow parameters input files based on the flow type information.
-
Define the Start state handler.
In the example above the flow only consists of the Start state handler and therefore only state handler is defined. As you can see in the AnalyzeClientMemory example provided earlier is it possible to chain state handlers with next_state="MyNextState". The name of the first state handler is Start. Multiple states can be defined as a list e.g. ["MyNextState1", "MyNextState2", …]. Results from one state to another are passed via the response argument.
The last state handler called that is always called is the End state handler, by default it return a generic "Flow completed" response. The End state handler can be overwritten to return more detailed status information. The End state handler does not need to be explicitly defined as a next state.
Testing
We aim to keep GRR well unit tested to ensure we can move quickly with new changes without unknowingly breaking things. Different pieces of the system are tested to different levels of rigour, but generally new functionality should not go in without a test.
Running the Tests
To run the tests there are a few dependencies you’ll need to make sure are sorted.
Testing the admin interface requires the webdriver/selenium framework. First you need to install the framework and chrome driver, we recommend using:
apt-get install python-pip # if you don't have it already sudo pip install selenium sudo apt-get install libnss3 chromium-browser # dependency of chromedriver wget https://chromedriver.googlecode.com/files/chromedriver_linux64_26.0.1383.0.zip unzip chromedriver* sudo mv chromedriver /usr/bin/
Use the run_tests.py script to run the unit tests.
joe@host:~/dev/grr$ PYTHONPATH="" python ./grr/run_tests.py SchedulerTest PASSED in 0.31s FlowFactoryTest PASSED in 0.41s NetstatTest PASSED in 0.40s SQLiteFileTest PASSED in 0.50s BackwardsCompatibleClientCommsTest PASSED in 0.91s GrrWorkerTest PASSED in 0.61s AFF4GRRTest PASSED in 0.41s ChromeHistoryTest PASSED in 0.41s AccessControlTest PASSED in 0.41s ... TestAdministrativeFlows FAILED in 0.41s ... TestFileCollector PASSED in 2.02s TestWebHistory PASSED in 1.31s Ran 75 tests in 8.98 sec, 74 tests passed, 1 tests failed.
To run a specific test name the test class on the command line:
joe@host:~/dev/grr$ PYTHONPATH="" python ./grr/run_tests.py TestAdministrativeFlows
Testing the UI
Note: If you are doing this on a remote machine over SSH you need to make sure your X display is forwarded for Selenium, it will spawn a Firefox window during the tests.
Then run the runtests_test.py script
joe@host:~/dev/grr$ PYTHONPATH="" python ./grr/gui/runtests_test.py
To run a specific test name the test class on the command line:
joe@host:~/dev/grr$ PYTHONPATH="" python ./grr/gui/runtests_test.py TestTimelineView
Debugging GUI Tests
Selenium will instrument the browser flow, but to figure out why something isn’t working it’s often useful to be able to single step through the Selenium actions. Add a call to import pdb; pdb.set_trace() into your test. e.g.
When the test hits this point it will break into a pdb shell for you to step through.
Debugging Client Actions
Client actions can be run manually without a flow by using the console. The following example shows using the ExecutePython client action without a flow.
A few points about the above code: - This runs a worker on a separate queue called DEBUG which means production workers won’t attempt to process them. - StartFlowAndWorker will create the flow, send the requests to the client, and start a worker to process the returned results. - break_pdb and save_to are special args to the ClientAction flow to help you debug interactively.
Key Libraries.
GRR makes use of a number of key open source projects in its implementation. These include:
-
AFF4 http://code.google.com/p/aff4/ (datastore uses aff4 design)
-
Django https://www.djangoproject.com/ (admin UI uses django templates)
-
Ipython http://ipython.org/ (Console is built on ipython)
-
Jquery http://jquery.com/ (UI code extensively uses jquery)
-
M2Crypto http://chandlerproject.org/Projects/MeTooCrypto/ (provides python encryption libraries for comms and signing)
-
Mongo http://www.mongodb.org/ (datastore runs on mongo)
-
Protobuf http://code.google.com/p/protobuf/ (messages and interfaces are defined as protobufs)
-
psutil http://code.google.com/p/psutil/ (used for native process and network data)
-
PyTSK http://code.google.com/p/pytsk/ (client uses pytsk to talk to tsk)
-
Sleuthkit http://www.sleuthkit.org/ (client uses tsk for raw access)
-
VerifySigs http://code.google.com/p/verify-sigs/ (used for authenticode signature handling and verification)
-
Volatility http://code.google.com/p/volatility/ (used for memory forensics capabilities)


INVALID_ADDRESS
The address the session tried to connect to does not point to a Zello channels server
toString
fun toString(): String


SWITCHBLADE SISTERS A film review by James Berardinelli Copyright 1996 James Berardinelli
RATING (0 TO 10): 2.0 Alternative Scale: * out of ****
United States, 1975 U.S. Re-release Date: 6/96 (limited) Running Length: 1:31 MPAA Classification: R (Violence, sex, profanity, nudity, bad wardrobe, worse dialogue) Theatrical Aspect Ratio: 1.85:1
Cast: Robbie Lee, Joanne Nail, Monica Gayle, Janice Karman, Asher Brauner, Kitty Bruce, Chase Newhart Director: Jack Hill Producer: John Prizer Screenplay: F.X. Maier Cinematography: Stephen Katz Music: Les Baxter U.S. Distributor: Rolling Thunder/Miramax Films
Once upon a time, Quentin Tarantino was a hot writer/director. His first and second films, RESERVOIR DOGS and PULP FICTION, wowed audiences worldwide, and made him a "can't-miss" commodity. Then, for some reason, he decided to concentrate on acting. Problem: he can't act. That didn't stop him, so movie-goers have been forced to endure Tarantino mugging for the camera in such titles as DESTINY TURNS ON THE RADIO, FOUR ROOMS, FROM DUSK TILL DAWN, and DESPERADO. Not content with writing, directing, and acting, Tarantino decided that he wanted to get into the film releasing business. So was born Rolling Thunder, a Miramax imprint. The first film released under this label was CHUNGKING EXPRESS, a sublimely thoughtful (if somewhat confusing) import. No such praise can be heaped upon SWITCHBLADE SISTERS, Rolling Thunder entry #2. A 1975 exploitation dud, this is the kind of movie Cinemax screens late at night. It's not just bad, it's execrable. If this is the kind of flick that Tarantino enjoyed while working at the video store, it's amazing that RESERVOIR DOGS turned out so well.
The plot of SWITCHBLADE SISTERS, such as it is, involves gang wars and in-fighting between the girls of the Dagger Debs (who are renamed the Jezebels mid-way through the film). These Switchblade Sisters have at least three problems: a rival gang leader (with the unforgettable name of Crabs) who wants them dead, a traitor in their midst, and a pair of cops (or, in the language of the day, pigs) who are waiting to bust them. The two lead Jezebels, Lace (Robbie Lee) and Maggie (Joanne Nail), are fighting over the same guy, Silver Daggers stud-leader, Dom (Asher Brauner), who knocks up one of them and forces himself on the other. Strangely, however, when Dom gets blown away by a blast from Crabs' gun, both Lace and Maggie want to waste Crabs, instead of shaking his hand.
Leather and lace. Studded boots and bell bottoms. An electro- disco score. Roller skating rinks. Afros. SWITCHBLADE SISTERS reeks of the worst excesses of the '70s. Calling it dated is an understatement. This is the kind of film that '90s movies delight in parodying. There's a certain campy value to a production like this (especially twenty years later), but only for about the first thirty minutes. Then things get repetitive and dull. This movie is too lifeless and amateurish to be enjoyable for long. If you want good, well-made, high-energy camp, check out any of Russ Meyer's films. Meyer (FASTER, PUSSYCAT! KILL! KILL!) made good bad stuff. Director Jack Hill (who was also responsible for THE SWINGING CHEERLEADERS) specialized in bad bad movies.
This is one of those rare movies where every member of the cast turns in an unbearably bad performance. There isn't anything remotely competent about any of the actors. The only one I recognized was Asher Brauner -- I think he was in a soap opera during the late '70s. Robbie Lee has a helium voice that is reminiscent of fingernails scraping across a blackboard. Joanne Nail looks like she could have been one of CHARLIE'S ANGELS (according to the production notes, she turned down the opportunity). All the actors literally snarl every line of dialogue. Then again, if I had to say the kind of inane lines they're given, I might be in a snarling mood, too.
One of the most laughable aspects of this film is that all the characters are supposed to be high school students, but the oldest actors are pushing 30. I guess some of them got held back a few times. There's a classic catfight where the Dagger Debs do battle with a nasty prison matron. During the tussle, we get a pretty good look at a stuntman in a wig.  And, of course, there's also the gratuitous topless scene, when one of the girls gets her shirt ripped off.
I won't completely dismiss this as celluloid tripe. For those who are inexplicably infatuated with the '70s, SWITCHBLADE SISTERS gives a glimpse of a different aspect of the era's pop culture than what is typically portrayed through nostalgia-tinged lenses. It's cheap, tawdry, and practically unwatchable, but some viewers will undoubtedly enjoy it -- after all, Tarantino can't be the only SWITCHBLADE SISTERS fan, can he? For my money, I'd prefer sitting through just about anything else currently playing in theaters -- even THE CABLE GUY. SWITCHBLADE SISTERS doesn't cut it on any level.
- James Berardinelli e-mail<EMAIL_ADDRESS>ReelViews web site: http://www.cybernex.net/~berardin
The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews


A python library to synchronize rows of data with a google spreadsheet.
Install from PyPi using pip, a package manager for Python.:
pip install sheetsync
Or to develop this library further, you can clone the git repo and install:
git clone git@github.com:mbrenig/SheetSync.git SheetSyncRepo
pip install SheetSyncRepo
Note, you may need to run the commands above with sudo.
SheetSync works with data in a dictionary of dictionaries. Each row is represented by a dictionary, and these are themselves stored in a dictionary indexed by a row-specific key. For example:
data = { "Kermit": {"Color" : "Green", "Performer" : "Jim Henson"},
"Miss Piggy" : {"Color" : "Pink", "Performer" : "Frank Oz"}
}
To insert this data (add or update rows) with a target sheet in a google spreadsheet document you do this:
import sheetsync
# Get or create a spreadsheet...
target =<EMAIL_ADDRESS>password="app-specific-password",
document_name="Let's try out SheetSync")
# Insert or update rows on the spreadsheet...
target.inject(data)
print "Review the new spreadsheet created here: %s" % target.document_href
This creates a new spreadsheet document in your google drive and then inserts the data like so:
Later on you’ll probably want to access this data, to do that note the spreadsheet’s document key from the URL:
and access the data as follows:
source =<EMAIL_ADDRESS>password="app-specific-password",
document_key="1bnieREGAyXZ2TnhXgYrIacCIY09Q2lfGXNZbjsvJ82M")
print source.data()
The ‘inject’ method only adds or updates rows. If you want to delete rows from the spreadsheet to keep it in sync with the input data then use the ‘sync’ method described in the ‘Synchronizing data’ section below.
Let’s extend this example, and use more of SheetSync’s features. (With apologies in advance to the Muppets involved).
The first thing we’ll fix is that top-left cell with the value ‘Key’. The keys for our data are Names and the column header should reflect that. This is easy enough to do with the key_column_headers field:
target =<EMAIL_ADDRESS>password="app-specific-password",
document_name="Muppet Show Tonight",
key_column_headers=["Name"])
Google’s spreadsheet API doesn’t currently allow control over cell formatting, but you can specify a template template spreadsheet that has the formatting you want - and use SheetSync to add data to a copy of the template. Here’s a template spreadsheet created to keep my list of Muppets:
https://docs.google.com/spreadsheets/d/1J__SpvQvI9S4bW-BkA0PmPykH8VVT9bdoWZ-AW7V_0U/edit#gid=0
The template’s document key is ‘1J__SpvQvI9S4bW-BkA0PmPykH8VVT9bdoWZ-AW7V_0U’ we can instruct SheetSync to use this as a basis for the new spreadsheet it creates as follows:
target =<EMAIL_ADDRESS>password="app-specific-password",
document_name="Muppet Show Tonight",
sheet_name="Muppets",
template_key="1J__SpvQvI9S4bW-BkA0PmPykH8VVT9bdoWZ-AW7V_0U",
key_column_headers=["Name"])
Note that I’ve also specified the worksheet name in that example with the ‘sheet_name’ parameter.
If you use folders to organize your Google drive, you can specify the folder a new spreadsheet will be created in. Use either the ‘folder_name’ or ‘folder_key’ parameters. Here for example I have a folder with the key “0B8rRHMfAlOZrWUw4LUhZejk4c0E”:
and instruct SheetSync to move the new spreadsheet into that folder with this code:
target =<EMAIL_ADDRESS>password="app-specific-password",
document_name="Muppet Show Tonight",
sheet_name="Muppets",
key_column_headers=["Name"],
template_key="1J__SpvQvI9S4bW-BkA0PmPykH8VVT9bdoWZ-AW7V_0U",
folder_key="0B8rRHMfAlOZrWUw4LUhZejk4c0E")
Often you’ll need some columns to contain formulas that depend on data in other columns, and when new rows are inserted by SheetSync, ideally you’d want those formulas to be added too. When initializing the spreadsheet you can specify a row (typically above the header row) that contains reference formulas. Best illustrated by this example
https://docs.google.com/spreadsheets/d/1tn-lGqGHDrVbnW2PRvwie4LMmC9ZgYHWlbyTjCvwru8/edit#gid=0
Here row 2 contains formulas (Written out in row 1 for readability) that reference hidden columns. Row 3 contains the headers.
When new rows are added to this spreadsheet the ‘Photo’ and ‘Muppet’ columns will be populated with a formula similar to the reference row. Here are the parameters to set this up:
target =<EMAIL_ADDRESS>password="app-specific-password",
document_key="1tn-lGqGHDrVbnW2PRvwie4LMmC9ZgYHWlbyTjCvwru8",
sheet_name="Muppets",
key_column_headers=["Name"],
header_row_ix=3,
formula_ref_row_ix=2)
animal = {'Animal': {'Color': 'Red',
'Image URL': 'http://upload.wikimedia.org/wikipedia/en/e/e7/Animal_%28Muppet%29.jpg',
'Performer': 'Frank Oz',
'Wikipedia': 'http://en.wikipedia.org/wiki/Animal_(Muppet)'} }
target.inject(animal)
Until now all examples have shown injecting data into a spreadsheet ot add or update rows. As the name suggests, SheetSync also has a ‘sync’ method which will make sure the rows in the spreadsheet match the rows passed to the function. This might require that rows are deleted from the spreadsheet.
The default behavior is to not actually delete rows, but instead flag them for deletion with the “(DELETED)” being appended to the values of the Key columns. This is to help recovery from accidental deletions, but might not be desirable. Full row deletion can be enabled by passing the flag_deletes argument as follows:
target =<EMAIL_ADDRESS>password="app-specific-password",
document_key="1J__SABCD1234bW-ABCD1234kH8VABCD1234-AW7V_0U",
sheet_name="Muppets",
key_column_headers=["Name"],
flag_deletes=False)
new_list = { 'Kermit' : { 'Color' : 'Green',
'Performer' : 'Jim Henson' },
'Fozzie Bear' : {'Color' : 'Orange' } }
target.sync( new_list )
With rows for Miss Piggy and Kermit already in the spreadsheet, the sync function (in the example above) would remove Miss Piggy and add Fozzie Bear.
Couldn’t the sync function delete all my rows? Yes it could!
Some simple mistakes can cause bad results. For instance, if the key column headers on the spreadsheet don’t match those passed to the Sheet constructor the sync method will delete all the existing rows and add new ones! You could protect rows and ranges to guard against this, but perhaps the simplest way to mitigate the risk is by creating a backup of your spreadsheet before syncing data. Here’s an example:
target.backup("Backup of my important sheet. 16th June",
folder_name = "SheetSync Backups.")
This code would take a copy of the entire spreadsheet that the Sheet instance ‘target’ belongs to, name it “Backup of my important sheet. 16th June”, and move it to a folder named “SheetSync Backups.”.
SheetSync uses the standard python logging module, the easiest way to find out what’s going on under the covers is to turn on all logging:
import sheetsync
import logging
# Set all loggers to DEBUG level..
logging.getLogger('').setLevel(logging.DEBUG)
# Register the default log handler to send logs to console..
logging.basicConfig()
If you find issues please raise them on github, and if you have fixes please submit pull requests. Thanks!


Theory - Free Vibrations
A single degree of freedom system has the equation of motion
\begin{equation}
M\ddot{r}+C \dot{r}+Kr=R
\end{equation}
If there is no applied force so that
\begin{equation}
R=0
\end{equation}
then the damped equation of motion is
\begin{equation}
m\ddot{r}+k\dot{r}=0
\end{equation}
This has the solution
\begin{equation}
\begin{array}{l}
r= r_{0}e^{pt}\\
\dot{r}= pr_{0}e^{pt} \\
\ddot{r} = p^{2}r_{0}e^{pt}
\end{array}
\end{equation}
Substituting these back into the equation of motion gives
\begin{equation}
(p^{2}m+pc+k)r_{0}e^{pt}=0
\end{equation}
If the amplitude of vibration is not zero then
\begin{equation}
(p^{2}m+pc+k)=0
\end{equation}
This is called the characteristic equation of the system. It has the solution
\begin{equation}
p= \frac{1}{2m} \bigg(-c \pm \sqrt[]{c^{2}-4km}\bigg )
\end{equation}
For a lightly damped system (in fact it defines a lightly damped system) then
\begin{equation}
c^{2} < 4km
\end{equation}
In this case:
\begin{equation}
p = -\frac{c}{2m} \pm i \frac{1}{2m}\sqrt[]{4km-c^{2}}= \alpha \pm \beta
\end{equation}
The response is then
\begin{equation}
r= r_{01} e^{\alpha t} e^{i \beta t} + r_{02}e^{\alpha t}e^{-i \beta t}
\end{equation}
Where $\beta$ is called the damped natural frequency.
\begin{equation}
\beta = \sqrt[]{\frac{k}{m}-\frac{c^{2}}{4m^{2}}}
\end{equation}
The equation of motion can also be written in non-dimensional form by dividing throughout by the mass.
\begin{equation}
\ddot{r}+\frac{c}{m}\dot{r}+\frac{k}{m}r = \frac{R}{m}
\end{equation}
or
\begin{equation}
\ddot{r}+2\omega_{u}\xi\dot{r} +\omega_{u}^{2}r=\frac{R}{m} %xi or zeta ?
\end{equation}
where
$\omega_{u}$= $\sqrt[]{\frac{k}{m}}$ is the undamped resonant frequency
$\xi$= $\frac{c}{2\omega_{u}m}$=$\frac{c}{2 \ \sqrt[]{km}}$=$\frac{c}{c_{0}}$ is the damping factor or damping ratio.
$c_{0}$=$2 \ \sqrt[]{km}$ is the critical damping value.
\begin{equation}
\beta= \omega_{u} \bigg( 1- \frac{c^{2}}{4km} \bigg)^{1/2} = \omega_{u}\big(1-\xi^{2}\big)^{1/2}
\end{equation}
and $\alpha$ is $\alpha$=$\omega_{u}\xi$


| Name | ID | |
| Abyssal Scepter | 3001 | |
| Aegis of the Legion | 3105 | |
| Aether Wisp | 3113 | |
| Amplifying Tome | 1052 | |
| Ancient Coin | 3301 | |
| Archangel's Staff (Crystal Scar) | 3007 | |
| Archangel's Staff | 3003 | |
| Ardent Censer | 3504 | |
| Athene's Unholy Grail | 3174 | |
| Avarice Blade | 3093 | |
| B. F. Sword | 1038 | |
| Banner of Command | 3060 | |
| Banshee's Veil | 3102 | |
| Berserker's Greaves - Enchantment: Alacrity | 3254 | |
| Berserker's Greaves - Enchantment: Captain | 3251 | |
| Berserker's Greaves - Enchantment: Distortion | 3253 | |
| Berserker's Greaves - Enchantment: Furor | 3252 | |
| Berserker's Greaves - Enchantment: Homeguard | 3250 | |
| Berserker's Greaves | 3006 | |
| Bilgewater Cutlass | 3144 | |
| Blackfire Torch | 3188 | |
| Blade of the Ruined King | 3153 | |
| Blasting Wand | 1026 | |
| Bonetooth Necklace | 3166 | |
| Bonetooth Necklace | 3167 | |
| Bonetooth Necklace | 3168 | |
| Bonetooth Necklace | 3169 | |
| Bonetooth Necklace | 3171 | |
| Bonetooth Necklace | 3405 | |
| Bonetooth Necklace | 3406 | |
| Bonetooth Necklace | 3407 | |
| Bonetooth Necklace | 3408 | |
| Bonetooth Necklace | 3409 | |
| Bonetooth Necklace | 3411 | |
| Bonetooth Necklace | 3412 | |
| Bonetooth Necklace | 3413 | |
| Bonetooth Necklace | 3414 | |
| Bonetooth Necklace | 3415 | |
| Bonetooth Necklace | 3417 | |
| Bonetooth Necklace | 3418 | |
| Bonetooth Necklace | 3419 | |
| Bonetooth Necklace | 3420 | |
| Bonetooth Necklace | 3421 | |
| Bonetooth Necklace | 3450 | |
| Bonetooth Necklace | 3451 | |
| Bonetooth Necklace | 3452 | |
| Bonetooth Necklace | 3453 | |
| Bonetooth Necklace | 3454 | |
| Boots of Mobility - Enchantment: Alacrity | 3274 | |
| Boots of Mobility - Enchantment: Captain | 3271 | |
| Boots of Mobility - Enchantment: Distortion | 3273 | |
| Boots of Mobility - Enchantment: Furor | 3272 | |
| Boots of Mobility - Enchantment: Homeguard | 3270 | |
| Boots of Mobility | 3117 | |
| Boots of Speed | 1001 | |
| Boots of Swiftness - Enchantment: Alacrity | 3284 | |
| Boots of Swiftness - Enchantment: Captain | 3281 | |
| Boots of Swiftness - Enchantment: Distortion | 3283 | |
| Boots of Swiftness - Enchantment: Furor | 3282 | |
| Boots of Swiftness - Enchantment: Homeguard | 3280 | |
| Boots of Swiftness | 3009 | |
| Brawler's Gloves | 1051 | |
| Catalyst the Protector | 3010 | |
| Chain Vest | 1031 | |
| Chalice of Harmony | 3028 | |
| Cloak of Agility | 1018 | |
| Cloth Armor | 1029 | |
| Crystalline Bracer | 3801 | |
| Crystalline Flask | 2041 | |
| Dagger | 1042 | |
| Deathfire Grasp | 3128 | |
| Dervish Blade | 3137 | |
| Diet Poro-Snax | 2054 | |
| Doran's Blade (Showdown) | 1075 | |
| Doran's Blade | 1055 | |
| Doran's Ring (Showdown) | 1076 | |
| Doran's Ring | 1056 | |
| Doran's Shield (Showdown) | 1074 | |
| Doran's Shield | 1054 | |
| Elixir of Iron | 2138 | |
| Elixir of Ruin | 2137 | |
| Elixir of Sorcery | 2139 | |
| Elixir of Wrath | 2140 | |
| Entropy | 3184 | |
| Essence Reaver | 3508 | |
| Explorer's Ward | 2050 | |
| Face of the Mountain | 3401 | |
| Faerie Charm | 1004 | |
| Farsight Orb (Trinket) | 3363 | |
| Fiendish Codex | 3108 | |
| Forbidden Idol | 3114 | |
| Frost Queen's Claim | 3092 | |
| Frostfang | 3098 | |
| Frozen Heart | 3110 | |
| Frozen Mallet | 3022 | |
| Giant's Belt | 1011 | |
| Glacial Shroud | 3024 | |
| Golden Transcendence | 3460 | |
| Greater Stealth Totem (Trinket) | 3361 | |
| Greater Vision Totem (Trinket) | 3362 | |
| Grez's Spectral Lantern | 3159 | |
| Guardian Angel | 3026 | |
| Guardian's Horn | 2051 | |
| Guinsoo's Rageblade | 3124 | |
| Haunting Guise | 3136 | |
| Head of Kha'Zix | 3175 | |
| Head of Kha'Zix | 3410 | |
| Head of Kha'Zix | 3416 | |
| Head of Kha'Zix | 3422 | |
| Head of Kha'Zix | 3455 | |
| Health Potion | 2003 | |
| Hexdrinker | 3155 | |
| Hextech Gunblade | 3146 | |
| Hextech Revolver | 3145 | |
| Hextech Sweeper | 3187 | |
| Hunter's Machete | 1039 | |
| Iceborn Gauntlet | 3025 | |
| Infinity Edge | 3031 | |
| Ionian Boots of Lucidity - Enchantment: Alacrity | 3279 | |
| Ionian Boots of Lucidity - Enchantment: Captain | 3276 | |
| Ionian Boots of Lucidity - Enchantment: Distortion | 3278 | |
| Ionian Boots of Lucidity - Enchantment: Furor | 3277 | |
| Ionian Boots of Lucidity - Enchantment: Homeguard | 3275 | |
| Ionian Boots of Lucidity | 3158 | |
| Kindlegem | 3067 | |
| Last Whisper | 3035 | |
| Liandry's Torment | 3151 | |
| Lich Bane | 3100 | |
| Locket of the Iron Solari | 3190 | |
| Long Sword | 1036 | |
| Lord Van Damm's Pillager | 3104 | |
| Madred's Razors | 3106 | |
| Mana Potion | 2004 | |
| Manamune (Crystal Scar) | 3008 | |
| Manamune | 3004 | |
| Maw of Malmortius | 3156 | |
| Mejai's Soulstealer | 3041 | |
| Mercurial Scimitar | 3139 | |
| Mercury's Treads - Enchantment: Alacrity | 3269 | |
| Mercury's Treads - Enchantment: Captain | 3266 | |
| Mercury's Treads - Enchantment: Distortion | 3268 | |
| Mercury's Treads - Enchantment: Furor | 3267 | |
| Mercury's Treads - Enchantment: Homeguard | 3265 | |
| Mercury's Treads | 3111 | |
| Mikael's Crucible | 3222 | |
| Moonflair Spellblade | 3170 | |
| Morellonomicon | 3165 | |
| Muramana | 3042 | |
| Muramana | 3043 | |
| Nashor's Tooth | 3115 | |
| Needlessly Large Rod | 1058 | |
| Negatron Cloak | 1057 | |
| Ninja Tabi - Enchantment: Alacrity | 3264 | |
| Ninja Tabi - Enchantment: Captain | 3261 | |
| Ninja Tabi - Enchantment: Distortion | 3263 | |
| Ninja Tabi - Enchantment: Furor | 3262 | |
| Ninja Tabi - Enchantment: Homeguard | 3260 | |
| Ninja Tabi | 3047 | |
| Nomad's Medallion | 3096 | |
| Null-Magic Mantle | 1033 | |
| Odyn's Veil | 3180 | |
| Ohmwrecker | 3056 | |
| Oracle's Extract | 2047 | |
| Oracle's Lens (Trinket) | 3364 | |
| Orb of Winter | 3112 | |
| Overlord's Bloodmail | 3084 | |
| Perfect Hex Core | 3198 | |
| Phage | 3044 | |
| Phantom Dancer | 3046 | |
| Pickaxe | 1037 | |
| Poacher's Knife - Enchantment: Devourer | 3722 | |
| Poacher's Knife - Enchantment: Juggernaut | 3721 | |
| Poacher's Knife - Enchantment: Magus | 3720 | |
| Poacher's Knife - Enchantment: Warrior | 3719 | |
| Poacher's Knife | 3711 | |
| Poro-Snax | 2052 | |
| Prospector's Blade | 1062 | |
| Prospector's Ring | 1063 | |
| Prototype Hex Core | 3200 | |
| Quicksilver Sash | 3140 | |
| Rabadon's Deathcap | 3089 | |
| Randuin's Omen | 3143 | |
| Ranger's Trailblazer - Enchantment: Devourer | 3726 | |
| Ranger's Trailblazer - Enchantment: Juggernaut | 3725 | |
| Ranger's Trailblazer - Enchantment: Magus | 3724 | |
| Ranger's Trailblazer - Enchantment: Warrior | 3723 | |
| Ranger's Trailblazer | 3713 | |
| Raptor Cloak | 2053 | |
| Ravenous Hydra (Melee Only) | 3074 | |
| Recurve Bow | 1043 | |
| Rejuvenation Bead | 1006 | |
| Relic Shield | 3302 | |
| Righteous Glory | 3800 | |
| Rod of Ages (Crystal Scar) | 3029 | |
| Rod of Ages | 3027 | |
| Ruby Crystal | 1028 | |
| Ruby Sightstone | 2045 | |
| Runaan's Hurricane (Ranged Only) | 3085 | |
| Rylai's Crystal Scepter | 3116 | |
| Sanguine Blade | 3181 | |
| Sapphire Crystal | 1027 | |
| Scrying Orb (Trinket) | 3342 | |
| Seeker's Armguard | 3191 | |
| Seraph's Embrace | 3040 | |
| Seraph's Embrace | 3048 | |
| Sheen | 3057 | |
| Sightstone | 2049 | |
| Skirmisher's Sabre - Enchantment: Devourer | 3718 | |
| Skirmisher's Sabre - Enchantment: Juggernaut | 3717 | |
| Skirmisher's Sabre - Enchantment: Magus | 3716 | |
| Skirmisher's Sabre - Enchantment: Warrior | 3714 | |
| Skirmisher's Sabre | 3715 | |
| Sorcerer's Shoes - Enchantment: Alacrity | 3259 | |
| Sorcerer's Shoes - Enchantment: Captain | 3256 | |
| Sorcerer's Shoes - Enchantment: Distortion | 3258 | |
| Sorcerer's Shoes - Enchantment: Furor | 3257 | |
| Sorcerer's Shoes - Enchantment: Homeguard | 3255 | |
| Sorcerer's Shoes | 3020 | |
| Soul Anchor (Trinket) | 3345 | |
| Spectre's Cowl | 3211 | |
| Spellthief's Edge | 3303 | |
| Spirit Visage | 3065 | |
| Stalker's Blade - Enchantment: Devourer | 3710 | |
| Stalker's Blade - Enchantment: Juggernaut | 3709 | |
| Stalker's Blade - Enchantment: Magus | 3708 | |
| Stalker's Blade - Enchantment: Warrior | 3707 | |
| Stalker's Blade | 3706 | |
| Statikk Shiv | 3087 | |
| Stealth Ward | 2044 | |
| Stinger | 3101 | |
| Sunfire Cape | 3068 | |
| Sweeping Lens (Trinket) | 3341 | |
| Sword of the Occult | 3141 | |
| Talisman of Ascension | 3069 | |
| Targon's Brace | 3097 | |
| Tear of the Goddess (Crystal Scar) | 3073 | |
| Tear of the Goddess | 3070 | |
| The Black Cleaver | 3071 | |
| The Black Spear | 3599 | |
| The Bloodthirster | 3072 | |
| The Brutalizer | 3134 | |
| The Hex Core mk-1 | 3196 | |
| The Hex Core mk-2 | 3197 | |
| The Lightbringer | 3185 | |
| Thornmail | 3075 | |
| Tiamat (Melee Only) | 3077 | |
| Total Biscuit of Rejuvenation | 2009 | |
| Total Biscuit of Rejuvenation | 2010 | |
| Trinity Force | 3078 | |
| Twin Shadows | 3023 | |
| Twin Shadows | 3290 | |
| Vampiric Scepter | 1053 | |
| Vision Ward | 2043 | |
| Void Staff | 3135 | |
| Warden's Mail | 3082 | |
| Warding Totem (Trinket) | 3340 | |
| Warmog's Armor | 3083 | |
| Wicked Hatchet | 3122 | |
| Will of the Ancients | 3152 | |
| Wit's End | 3091 | |
| Wooglet's Witchcap | 3090 | |
| Wriggle's Lantern | 3154 | |
| Youmuu's Ghostblade | 3142 | |
| Zeal | 3086 | |
| Zeke's Herald | 3050 | |
| Zephyr | 3172 | |
| Zhonya's Hourglass | 3157 | |
| Zz'Rot Portal | 3512 |


Functions for computing, comparing and demonstrating top informative centrality measures within a network.
| Version: | 1.1.50 |
| Imports: | igraph, network, sna, centiserve, FactoMineR, factoextra, GGally, pheatmap, corrplot, dendextend, viridis, ggplot2, Rtsne, qdapTools, plyr, circlize, intergraph |
| Suggests: | knitr, rmarkdown |
| Published: | 2018-08-23 |
| Author: | Minoo Ashtiani, Mehdi Mirzaie, Mohieddin Jafari |
| Maintainer: | Minoo Ashtiani <m_ashtiani at pasteur.ac.ir> |
| License: | GPL-3 |
| NeedsCompilation: | no |
| CRAN checks: | CINNA results |
| Reference manual: | CINNA.pdf |
| Vignettes: |
CINNA |
| Package source: | CINNA_1.1.50.tar.gz |
| Windows binaries: | r-devel: CINNA_1.1.50.zip, r-release: CINNA_1.1.50.zip, r-oldrel: CINNA_1.1.50.zip |
| OS X binaries: | r-release: CINNA_1.1.50.tgz, r-oldrel: CINNA_1.1.50.tgz |
| Old sources: | CINNA archive |
Please use the canonical form https://CRAN.R-project.org/package=CINNA to link to this page.


Home > Data Structures and Algorithms Questions > How to Reverse a Linked List ?
Here's a code snippet to check if two binary trees are same or not.
static void reverse(struct Node** head_ref)
{
struct Node* prev = NULL;
struct Node* current = *head_ref;
struct Node* next = NULL;
while (current != NULL) {
// Store next
next = current->next;
// Reverse current node's pointer
current->next = prev;
// Move pointers one position ahead.
prev = current;
current = next;
}
*head_ref = prev;
}


{% extends 'url_shortener/base.html' %} {% block title %}URL Not Found - {{ title }}{% endblock %} {% block content %}
Please make sure that the URL is correct.


Staff Ratio: 8:1
Hardware + Software:
Python, Scikit-Learn, Tensoflow, Javascript
Ages: 12–18
Date：7.22–7.26 / 7.29–8.2
Hours: 9:00AM–4:30PM
Program: Teen Camp (Two-week)
At the beginning of the first week, students will work to understand the basics of how machine learning and AI works, affects our world, and start making their own machine learning powered projects with block-based programming. As the course progresses, students will master the basics of programming in python, creating machine learning projects like chatbots, predictive models, and bots that learn to play games.
At the beginning of the second week, students will explore ways that AI is applied to data, tools, and how services, and how they can apply AI to their own projects. By the end of the week, students will dive in the theory and math of machine learning, and solve data problems using those skills and strategies.
What Students Learn
What Students Create
Computer programming code runs your devices and the world. Our Programming courses prepare students with the skills they need to develop their own apps and games in languages such as C#, Java, and Swift. In the AI and Machine Learning course, students will take a deep dive into the complex algorithms that are making computers smarter than ever. Use neural nets to finally beat that game you’ve never been able to or improve projects using computer vision to find patterns. No programming experience is required, but a strong understanding of algebra and comfort with mathematics is very highly recommended.
The Teen Experience: Since 2002, Digital Media Academy has been encouraging and inspiring teens to become the next generation of developers, animators, filmmakers, photographers, designers and engineers. In addition to developing teens’ interests and passions for the latest in new tech, our camps foster personal growth, confidence, and independence; preparing students for life beyond high school and college.
COURSE: Artificial Intelligence Academy
DATE: 7.22–7.26 / 7.29–8.2
CLASS TIME: 9:00AM–4:30PM
** If you have any question, feel free to contact us or scan the QR code at the bottom right corner to add IFU Wechat Assistant for more help.


You can query QuickGO using a number of different identifier types (including: DictyBase, UniGene, UniProtKB, FlyBase, Gramene, Mouse Genome Informatics, GeneDB (S. Pombe), The Institute of Genome Research, WormBase, The Zebrafish Information Network, Ensembl, NCBI Reference Sequences, EMBL accession and NCBI Entrez Gene identifiers).
You can enter a single identifier into the search box on QuickGO's home page (or in the header on other pages) to retrieve the matching UniProt accession and link to its annotations.


Here are some examples of past projects
Links to each project are provided below, please feel free to get in touch with any questions or comments!


-
CA Technologies
Prague, Czech Republic
Senior Software Engineer
Sep 2017 - May 2019
Developing of API Mediation Layer (github.com/zowe/api-layer) a microservice-based system that provides a single point of access for
mainframe REST APIs using Spring Boot, Spring Cloud Netflix and Spring Security.
-
4finance
Prague, Czech Republic
Senior Software Engineer
Aug 2016 - Jul 2017
Refactor monolithic application to microservice architecture with Spring Cloud tech stack.
-
EPAM Systems
Gomel, Belarus
Senior Software Engineer
Dec 2013 - May 2016
Implementing SSO with Spring Framework and AngularJS.
Act as backup for the team lead in case of vacation.
-
IMMSP
Kyiv, Ukraine
Software Engineer
Jul 2010 - Aug 2012
Developing a cloud-based system for ECG analysis with Java EE technologies.


BABY BOY A film review by Steve Rhodes Copyright 2001 Steve Rhodes RATING (0 TO ****): ** 1/2
"Why are you so afraid to leave the nest?" Jody's mother (A.J. Johnson) asks him.  He reminds his mother, who doesn't look much older than he does, that "her" home originally belonged to his grandmother.
The theme of BABY BOY is the way that society has encouraged black men to never grow up. As proof of this thesis, we are reminded in voice-over of the words that black men use to describe their world. Their girlfriends are called their "mamas," their buddies are their "boys" and their home is their "crib."
Jody's mother is about to start a live-in arrangement with Melvin (Ving Rhames), an ex-con who recently spent ten years in San Quentin for "killing folks and other stuff." Jody tries to be cool around Melvin, which isn't always easy. "You have a good time, mama," Jody tells her on her first date out with Melvin. "You remember your curfew." A bigger challenge comes when Jody wakes one morning to find a buck-naked Melvin fixing eggs in the kitchen. With Melvin's rippling muscles and big tattoos, this makes for an impressive image. Quite upset that Melvin is devouring all of the Kool-Aid -- notice the choice of a child's drink -- Jody wants to say something, but criticizing Melvin does not seem like a promising idea.
Jody has ambitions. Figuring that humanity can be dichotomized into the buyers and the sellers, he wants to be one of the latter since those are the ones who become wealthy. In order to accomplish his version of the American dream, he steals women's clothes from a wholesaler and sells them in the neighborhood.
The film's recurring image is that of a grown man still in the womb. Shocking and mildly cute at first, this is a visual that rapidly loses its appeal.
Written and directed by John Singleton, who was responsible for the recent SHAFT remake as well as one of my personal favorites, ROSEWOOD, BABY BOY never rises above the level of a soap opera. Yes, it is a well made soap opera, but not one that we care much about. Then again, some people can't get enough of the TV soaps and dutifully set tapes to keep up with each day's shenanigans.
BABY BOY runs 2:09. It is rated R for strong sexuality, language, violence and some drug use and would be acceptable for older teenagers.
The film is playing now in nationwide release in the United States. In the Silicon Valley, it is showing at the AMC and the Century theaters.
Web: http://www.InternetReviews.com Email<EMAIL_ADDRESS>Want free reviews and weekly movie and video recommendations via Email? Just send me a letter with the word "subscribe" in the subject line.
========== X-RAMR-ID: 28848 X-Language: en X-RT-ReviewID: 236385 X-RT-TitleID: 1108382 X-RT-SourceID: 703 X-RT-AuthorID: 1271 X-RT-RatingText: 2.5/4
The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews


Import an Excel worksheet of new listings:
OR
Import a saved map:
Select the listing statuses to include:
Note: Each listing will cost a geocoding API request.
Locating MLS listings...
| MLS ID | Status |
|---|
| MLS ID: | Status Change Date: | ||
|---|---|---|---|
| Full Name: | Listing Status: | ||
| Address: | Tax Address: | ||
| Phone: | List Agent: | ||
| Email: | List Price: | ||
| Property Type: | Last Call Result: |
Notes:
Copyright © 2019 Bryce St. Pierre.
Made with in Ottawa.