| Age | Commit message (Collapse) | Author |
|---|
|
The "Hint" provide a general description for Target, a single HttpTarget,
and WebSocketTarget.
|
|
The hint is a text that will be displayed when the icon "i" on the
right side of input is clicked. It provide a description of input.
|
|
Previously, the web user interface is written in pure, single JavaScript
file. The LOC is short but its become hard to maintenance, especially
when there is a change in HTML layout or on the response format.
This changes rewrite the interface to use TypeScript in order to easily
maintenance. The generated JavaScript is loaded using module [1].
[1] https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Modules
|
|
This is to make the target title distinguishable in between another
titles.
|
|
Previously only HTTP/WS targets that have their link when the navigation
item is clicked.
This changes make the header target to be clickable too.
Also, changes the hash path to use the following format,
* "/${target.ID}" - for target only
* "/${target.ID}/http/${httptarget.ID}" - for HTTP target
* "/${target.ID}/ws/${httptarget.ID}" - for WebSocket target
|
|
If the HTTP target IsCustomizable, user can set the request method,
path, and/or request type. When user changes those values, the values
should overwrite the configuration on server, so the Run method can use
it for creating request.
|
|
When user click the target, the location hash will be set to the
target id. By setting the hash, we can allow user to refresh the page
and render the previous selected target.
|
|
|
|
|
|
Previously, the Attack button always showed even for HTTP target that
have AllowAttack false. This can be misleading for user.
This changes, show the Attack button only if AllowAttack is true.
While at it, reformat the JavaScript file with prettier.
|
|
This is to minimize number of files being served by server.
|
|
|
|
The ConvertParams is a function that will be called inside the Run
handler to convert the Params values to type that will be send as
request.
|
|
|
|
|
|
If the response type is "application/json", display the body as formatted
JSON with two space identation.
|
|
|
|
When the target variables changes and user click "Run" all of its
modified values will be passed inside Target.Vars.
|
|
|
|
When user changes the Target Options, including Duration, Rate per second,
and Timeout; store its value back to Target instance and pass it
when calling attack.
|
|
Any response from the trunks API must have the following format,
{
"code": <number>,
"message": <number>,
"data": <object>
}
|
|
|
|
|
|
If the HttpTarget.PreAttack is not set we should not call it.
While at it, reset the RunRequest result to nil at the end of attack.
|
|
The returned value can be set by the caller later, so to minimize
checking for nil and recreate the instance, initialize the value in
the function and return it even if its empty.
|
|
Instead of []byte, the call to Run on WebSocketTarget can return anything,
since we will wrap it inside the EndpointRequest.Data later.
|
|
The Target Vars or HTTP Target headers names can be longer and it will
overlap with input if its displayed in one row.
This changes render the Vars and headers label in single row and the
input in another row below it.
|
|
The content of _www directory is required to run the trunks as library.
|
|
|
|
|
|
While at it, fix height and autoscroll on left navigation.
|
|
Previously, we display the actual response of the HTTP target only
on the user interface.
This changes make the Run function to display the actual HTTP request and
response that being send and received on HTTP target.
|
|
Previously, the HttpTarget Method, Path, and RequestType is fixed.
Once its declared, the Run method will use the defined values to
generate and call HTTP request.
This changes add IsCustomizable field on HttpTarget. If its true,
client or web user interface can modify the request method, path, and
type. The values send by client to server after changes will be used
instead of the fixed values.
This changes also make the Run handler on HttpTarget to be optional.
If its not defined, it will generated the HTTP request from the method,
path, and type passed to server.
|
|
The trunks directory on command is actually the main program for
example package.
|
|
Previously, the HttpTarget Name field is optional, and the ID is derived
from Path.
This changes make the Name field become required and changes the ID to
be derived from Name instead of Path, because one or more same path
can be used by more HttpTarget.
|
|
Check for error where it should and remove unused return and methods.
|
|
One can register WebSocketTarget just like HttpTarget, its have ID,
Name, Headers, and Params.
Unlike HTTP, the WebSocket target only able to execute Run, it does not
have "Attack", yet.
|
|
The BaseUrl seems like not a good fit on AttackOptions since its
should never changes, so we move it to the Target.
|
|
|
|
The README briefly describe the module and show some screenshots, similar
with the module documentation.
|
|
|
|
The minimize screen size is 740px when the layout become one column,
from top to bottom, instead of two-columns, left and right.
|
|
On the top of the page, it will display currently running attack with
target name and HTTP target name. User can cancel the attack by
clicking "Cancel" button on the right.
|
|
When user clicking the "Delete" button on attack result item, it will
send request to API to delete the selected item. Server will check
if the requested result file name exist and delete them from file system
if its exist, otherwise it will return 404 Not found.
|
|
When the service started, it will load all previous attack results
from directory Environment.ResultsDir.
It will only scan the file name and append it to HttpTarget.Results
due to the size and time to load one of them can take time.
Through the web interface, user can click "Show" button to load
the result and display it on the screen.
|
|
* Increase the DEBUG value to 3 to match with latest libhttp fix
debug output of client request
* _www: fix rendering HTTP headers, missing "target" parameter
* Remove unused "IsRunning" from AttackResult
* example: add an example endpoint for POST with x-www-form-urlencoded
* Remove parameter Target on HttpRunHandler. The Target value can be
retrieved from RunRequest.Target.
* Target: change the field Vars type from map[string]string to KeyValue
* Trunks: merge Target and HttpRequest from request to original Target
and HttpTarget respectively before calling Run
* Prefix the result file name with Target.ID
* Move the package documentation to doc.go
|
|
|
|
The request type has been replaced with RunRequest.
The WebSocketTarget may be used again later, but let remove then now
to make the documentation clear.
|
|
When the user click "Attack" it will call the API to run the load testing.
If there is load testing currently, it will return with an error.
On success, the result of load testing will be stored on directory
defined in Environment.ResultsDir with file named
<HttpTarget.ID>.<date_time>.<RPS>x<Duration>s.<ResultsSuffix>.bin
This file contains the vegeta.Results.
|
|
The correct module name registered on go.mod is
github.com/tsenart/vegeta/v12.
|
