rockstor / rockstor-core Goto Github PK

On the create share page, use a range / slider plugin to make file size input more user-friendly.
For share size input, there should be a slider with max and min, and an input field next to it. - Moving the slider changes the value in the input field.

• If the user changes the value in the input field directly, the slider should update to match the value in the input field. The keyUp event on the field should help you do this.

Here are a couple of plugins that do this
http://loopj.com/jquery-simple-slider/
http://refreshless.com/nouislider/

Take a look at these and let me know if you have any questions.

Clone is a writable snapshot of a share. The user should be able to clone a share and use that clone as a brand new share. At the time of creation, the clone has identical data as the share from which it is created. But in all other respects, its a brand new share(with preexisting data) and completely so past the creation time.

There is no handler for the button, it needs to be written. It should be similar to Delete on the Shares page.

Reboot the machine and try to create a pool
You get the error ' wrong fs type, bad superblock'
Going to the disks page and doing a rescan appears to fix it, you can create a pool after the rescan.

Nginx and Gunicorn need to be configured properly to avoid nginx gateway timeout.

I don't have a reproducible case but seen it every time a certain operation, share creation for example, takes a while.

Until we change the api implementation to return immediately, it worth generously increasing necessary timeout variables in nginx and gunicorn configuration.

In production scenarios, there are usually 100's of disks, snapshots, shares and may be even pools.

Implement pagination in the API for these resources.
Update the frontend to support pagination.

Implement a layout framework for the dashboard that supports

1. Adding a widget to the dashboard from a menu
2. Maximize and close actions on a widget
3. Save the layout on changes so that it can be restored every time the user visits the dashboard.

The official djangorecipe does not honor buildout's relative-path directive. If it does, then db migration in production(via rpm) succeeds. There's a patch out there since 2011 but it hasn't made its way into djangorecipe.

As a temporary fix, implement a canned bin/django script that is pulled during rpm install time.

This does not effect dev environments, fix needed only for production.

Disk names should not be links (for now). They can be changed back to links when we have more content for the disk details page.
Remove the disk details page.

To prevent the user clicking the Submit button multiple times

Create a share of 100MB and go to the share details page. Click on Resize. the resize form shows the size as 100KB

The resize share form and the submit function should do the same conversions assuming the share size from the backend is in KB.

Support case should have a summary line and the notes should be a textarea where the user can enter a large amount of input.

When the user logs in for the first time, and goes through the setup process, and arrives at the dashboard. there should be help text / messaging on the dashboard that tells the user about:

1. where to go to create pools / shares
2. how to configure the dashboard

After a fresh Reboot or new installation try to create a pool

You get the error ['mount: wrong fs type, bad option, bad superblock on /dev/sdh,', ' missing codepage or helper program, or other error', ' In some cases useful info is found in syslog - try', ' dmesg | tail or so', '', '']

For each nfs export, it should display the command the user can run to mount the share through nfs.

Currently stored in GB. For consistency across the API, store them in KB.

Login page should have username / password labels, and RockStor description / motto on the right.

commands concatenated together don't work first time around when a earlier command fails

eg:
[extra-stuff]
recipe = plone.recipe.command
command = mkdir -p ${buildout:directory}/var/{log,run} &&
usermod -a -G root nginx &&
chkconfig nginx off &&
rm ${buildout:directory}/src/rockstor/{datastore,smartdb} &&
export DJANGO_SETTINGS_MODULE=settings &&
${buildout:directory}/bin/django syncdb --database=default --noinput &&
${buildout:directory}/bin/django syncdb --database=smart_manager --noinput &&
${buildout:directory}/bin/prep_db
update-command = ${extra-stuff:command}

Green = running
gray = stopped
etc

The UI code sends a POST to /shares//resize. There is no url specifically for resize in urls.py, so this is handled by post in share.py which causes an error.
Please take a look and assign it back to me when the UI code needs to be modified.

Implement a dashboard widget for showing the top N shares (top by space used, also investigate other parameters).

1. The widget should make an api call to retrieve N top shares by size. N should be a query parameter.
2. The return data should have growth info for a certain period of time. (1 month, a week? decide on this).
3. Display this data as a sparkline.
4. Should this poll or just have a refresh button. Decide depending on what data is going to be shown and how frequently it will change.

some useful documentation links:

https://docs.djangoproject.com/en/dev/ref/settings/#append-slash

https://docs.djangoproject.com/en/1.4/topics/http/urls/

The rule is described in http://rockstor.com/api (second rule in URIs section)

ensure that the trailing slash'd links are redirected properly.

Steps to reproduce

1. Create a RAID0 pool and create a single share.
2. Delete the share
3. Now create a new share. You get the error 'ERROR: cannot create subvolume - File exists'
4. Now go to the shares page and try creating a share again. You get the error 'mount: /dev/sdd already mounted or /mnt2/p1 busy', 'mount: according to mtab, /dev/sdd is already mounted on /mnt2/p1',

This also happens if you have more than one share, delete all of them, and then try to create a new share.

The added_at column in the disks table has hardcoded values right now. The disks json doesnt return a creation date. Either the backend should be modified to return this information, or the column removed from the table. It should be removed from the disks table in both the setup screen and the disks page.

Currently, the smart manager recipe execution framework is not very robust. It needs some refinement to be generic and robust to help add new recipes and extend easily.

1. Update the data model to include Recipe, RecipeInstance and RecipeData
2. refine stap.py to implement the discussed state machine for the nfs recipe set.
3. Update api interaction code including views and urls to support nfs recipe set.

Reduce the size of the logo and padding so that the navbar occupies less space

1. Display the string to use to mount the share using nfs in the share page
2. Make it possible to mount/use nfs as a non root user.

Create a share, say share1 in pool1
then create a share, say share2 in a different pool, pool2.

Both of them get get same share_id which breaks the unique constraint in qgroup.

South creates the migration history table only in the default database, and while doing smart_manager migrations, either tries to do them in the default database, or doesnt find the migration history table in the smart_manager db when the --database option is specified. Fix it by creating the migration history table manually in the smart_manager db.

http://docs.seleniumhq.org/docs/03_webdriver.jsp

Setup automated browser tests using selenium webdriver. The tests will be written in python.
These tests will also be run by the continuous integration setup (coming soon)

This is in response to the error reported by Deepak.

Traceback (most recent call last):
File "/opt/rockstor/src/rockstor/storageadmin/views/pool.py", line 96, in post
add_pool(pname, raid_level, raid_level, disks)
File "/opt/rockstor/src/rockstor/fs/btrfs.py", line 44, in add_pool
out, err, rc = run_command(cmd)
File "/opt/rockstor/src/rockstor/system/osi.py", line 85, in run_command
raise CommandException(out, err, rc)
CommandException: ["mkfs.btrfs: mkfs.c:82: make_root_dir: Assertion `!(ret)' failed.", '']
[02/May/2013 21:56:03] DEBUG [storageadmin.util:24] request data: <QueryDict: {u'disks': [u'sdd,sdb,sdc'], u'pname': [u'P1'], u'raid_level': [u'raid0']}>

I've reproduced the error and looked at the mkfs.c. this happens when btrfs can't even allocate the first small block group.

This is not a problem for physical harddrives, but for small virtual disks, this is a real issue. Discarding drives < 1GB in size solves this problem. Disks even as small as 100MB will work, but there would be barely any space for file creation after that. 1GB is the minimum that can support file creation and other I/O for a while.

CPU Usage widget should

1. display CPU usage - % of time spent in user mode, user mode (nice), system mode, idle mode for the last 60 seconds
2. display legend
3. display timestamp on x axis

Whenever the size of anything is displayed, it should be converted to a user friendly format like 5K, 5MB, 5GB, 5TB etc instead of displaying everything in the same units.

Madhuri, take a look at some of the humanize libraries in javascript that help you do this. Here are a couple that you can investigate. If you come across any others you're welcome to try them too.
https://github.com/taijinlee/humanize
https://github.com/HubSpot/humanize

Here's an initial list of pages that display size information to get you started, fix them one by one. You can add to this list as you come across others.
Disks page
Pools page
Shares page

Keep in mind that the units of file size returned by the json is not the same in all cases..for example the disks json seems to return size in gb, and the pools in kb.

As a side note, these libraries support humanizing other things besides file sizes, like dates, so if you come across any place in the application where the library can be used to make it more user friendly, please file a bug.
Also, if you see nodejs as a requirement for any of these libraries, it is only required if you're running it on the server side, it should be possible to just use the js file for front-end use. Let me know if you have any questions.

Setup a VM (call it rockstor-staging) with RockStor 1.4, and a continuous integration framework using hudson that will do the following on every checkin into master

1. Kick off a process to build a new rockstor rpm
2. Update rockstor-staging with this new rpm
3. Run the webdriver test suite against rockstor-staging.
4. Log and email the results

Split urlpatterns into multiple files to be included in the main urls.py, so url updates can be nicely isolated and patterns become more readable.

Steps to reproduce:

1. Create two pools, p1 and p2
2. Go to the pool details page for p2
3. Click on Add Share
4. On the Create Share page p2 should be preselected but p1 is.

On the create share page, for the size input, the user should be allowed to enter sizes in Kb, Mb, or Gb, and this should be clearly indicated.

For an already created share, if you click the resize button from the share's detail page the resize form pops up. It is very minimalistic right now. improve the form such that:

1. Just like share creation process, the user should have KB, MB, GB and TB dropdown
2. The form should display the current size
3. It should ask the user "enter new size"

The create share button should not be enabled when no pools have been created. The Shares page should instead display messaging that informs the user that they have to create a pool before being able to create a share.

Create a samba share with guest ok = yes and read_only = yes, and some comment. The samba share is created with guest_ok = no and read_only = no.

Implement a widget and framework to run systemtap probes from the dashboard.

The 'probe' widget should:

1. Support adding to the dashboard from the widget menu. (Decide on how to implement this, does this remove other widgets so that the user can focus on this, or is it just another widget?)
2. Widget has Play, Pause/Resume, and Stop actions. Play starts the probe, pause pauses, and stop stops the probe
3. When the user starts the probe, the data might take a while to be populated in the db. The widget should poll for data, and till it starts arriving, should inform the user that the probe is running and it is waiting for data.
4. The widget should show related probes that the user can select. Selecting a related probe will stop the current one and make the selected one ready to run.
5. The user should be able to close the widget and go back to the main dashboard..(exact implementation depends on how 1 is implemented.)

RPM updates shouldn't wipe out appliance's databases -- datastore and smart_manager included.

Currently, Snapshots are implemented in a basic fashion. Refine the implementation where a snapshot of a share represents a read-only point in time representation of the share.

Show the pool usage in the usage area.

Steps to reproduce

1. Create a pool with raid0 and two disks sdb, sdc
2. Go to the pool and click on Add Share and create a share with the name 's1' and some size.
3. Go to Shares page, and do Add Share again, and try to create a share with the same name 's1' and some size.
4. You get the error popup with the message ["ERROR: '/mnt2/p1/s1' exists", '']
5. Close the error dialog, go to the shares page, click on Add Share again, and now try to create a share with a different name.
6. You get the error "['mount: /dev/sdb already mounted or /mnt2/p1 busy', 'mount: according to mtab, /dev/sdb is already mounted on /mnt2/p1']"

(There is a different bug where the new error message gets appended to the current one, so you might see the earlier error message too.. I'm in the process of fixing this)

Create a models directory
Split models.py into individual model files in the models dir.
Import these models in the models dir's init.py

Implement the following nfs recipe set

1. nfs calls over time for the entire server
2. nfs calls over time for a particular client
3. nfs class over time for a particular share
4. nfs calls over time of a particular file

Refine this issue description as implementation solidifies.